diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index e4bab21..93d727b 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -1,4 +1,4 @@
-// Copyright(c) 2015-2016, NVIDIA CORPORATION. All rights reserved.
+// Copyright(c) 2015-2019, NVIDIA CORPORATION. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -23,114 +23,4243 @@
 #include <iterator>
 #include "VulkanHppGenerator.hpp"
 
-const size_t INVALID_INDEX = (size_t)~0;
+bool beginsWith(std::string const& text, std::string const& prefix);
+bool endsWith(std::string const& text, std::string const& postfix);
+template <typename T> void checkAlias(std::map<std::string, T> const& data, std::string const& name, int line);
+void checkAttributes(std::map<std::string, std::string> const& attributes, int line, std::map<std::string, std::set<std::string>> const& required, std::map<std::string, std::set<std::string>> const& optional);
+void checkElements(std::vector<tinyxml2::XMLElement const*> const& elements, std::set<std::string> const& values);
+void checkEmptyElement(tinyxml2::XMLElement const* element);
+void checkOrderedElements(std::vector<tinyxml2::XMLElement const*> const& elements, std::vector<std::string> const& values);
+std::string createEnumValueName(std::string const& name, std::string const& prefix, std::string const& postfix, bool bitmask, std::string const& tag);
+std::string determineCommandName(std::string const& vulkanCommandName, std::string const& firstArgumentType);
+std::set<size_t> determineSkippedParams(size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices);
+bool determineStructureChaining(std::string const& structType, std::set<std::string> const& extendedStructs, std::map<std::string, std::string> const& structureAliases);
+void enterProtect(std::ostream &os, std::string const& protect);
+std::map<std::string, std::string> getAttributes(tinyxml2::XMLElement const* element);
+std::vector<tinyxml2::XMLElement const*> getChildElements(tinyxml2::XMLElement const* element);
+std::string getEnumPostfix(std::string const& name, std::set<std::string> const& tags, std::string & prefix);
+std::string getEnumPrefix(std::string const& name, bool bitmask);
+void leaveProtect(std::ostream &os, std::string const& protect);
+std::string readArraySize(tinyxml2::XMLNode const* node, std::string& name);
+void readStructStructExtends(std::map<std::string, std::string> const& attributes, std::vector<std::string> & structExtends, std::set<std::string> & extendedStructs);
+std::string replaceWithMap(std::string const &input, std::map<std::string, std::string> replacements);
+std::string startLowerCase(std::string const& input);
+std::string startUpperCase(std::string const& input);
+std::string stripPostfix(std::string const& value, std::string const& postfix);
+std::string stripPluralS(std::string const& name);
+std::string stripPrefix(std::string const& value, std::string const& prefix);
+std::string writeReinterpretCast(bool leadingConst, std::string const& type, bool trailingPointerToConst);
+std::string toCamelCase(std::string const& value);
+std::string toUpperCase(std::string const& name);
+std::vector<std::string> tokenize(std::string tokenString, char separator);
+std::string trim(std::string const& input);
+std::string trimEnd(std::string const& input);
+void writeArgumentCount(std::ostream & os, size_t vectorIndex, std::string const& vectorName, std::string const& counterName, size_t returnParamIndex, size_t templateParamIndex, bool twoStep, bool singular);
+void writeBitmask(std::ostream & os, std::string const& bitmaskName, std::string const& bitmaskAlias, std::string const& enumName, std::vector<std::pair<std::string, std::string>> const& enumValues);
+void writeBitmaskToStringFunction(std::ostream & os, std::string const& flagsName, std::string const& enumName, std::vector<std::pair<std::string, std::string>> const& enumValues);
+void writeEnumToString(std::ostream & os, std::string const& enumName, std::vector<std::pair<std::string, std::string>> const& enumValues);
+std::string writeFunctionBodyEnhancedLocalReturnVariableSingular(std::ostream & os, std::string const& indentation, std::string const& typeName, std::string const&returnName, bool isStructureChain);
+std::pair<bool, std::string> writeFunctionBodyStandardReturn(std::string const& returnType);
 
-const std::string vkNamespace = R"(
-#if !defined(VULKAN_HPP_NAMESPACE)
-#define VULKAN_HPP_NAMESPACE vk
-#endif
-
-#define VULKAN_HPP_STRINGIFY2(text) #text
-#define VULKAN_HPP_STRINGIFY(text) VULKAN_HPP_STRINGIFY2(text)
-#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY(VULKAN_HPP_NAMESPACE)
-
-namespace VULKAN_HPP_NAMESPACE
+bool beginsWith(std::string const& text, std::string const& prefix)
 {
+  return !prefix.empty() && text.substr(0, prefix.length()) == prefix;
+}
+
+bool endsWith(std::string const& text, std::string const& postfix)
+{
+  return !postfix.empty() && (postfix.length() <= text.length()) && (text.substr(text.length() - postfix.length()) == postfix);
+}
+
+template <typename T>
+void checkAlias(std::map<std::string, T> const& data, std::string const& name, int line)
+{
+  if (data.find(name) == data.end())
+  {
+    std::stringstream ss;
+    ss << line;
+    std::string lineNumber = ss.str();
+
+    throw std::runtime_error("Spec error on line " + lineNumber + ": missing alias <" + name + ">");
+  }
+}
+
+// check the validity of an attributes map
+// attributes : the map of name/value pairs of the encountered attributes
+// line       : the line in the xml file where the attributes are listed
+// required   : the required attributes, with a set of allowed values per attribute
+// optional   : the optional attributes, with a set of allowed values per attribute
+void checkAttributes(std::map<std::string, std::string> const& attributes, int line, std::map<std::string, std::set<std::string>> const& required, std::map<std::string, std::set<std::string>> const& optional)
+{
+  std::stringstream ss;
+  ss << line;
+  std::string lineNumber = ss.str();
+
+  // check if all required attributes are included and if there is a set of allowed values, check if the actual value is part of that set
+  for (auto const& r : required)
+  {
+    auto attributesIt = attributes.find(r.first);
+    if (attributesIt == attributes.end())
+    {
+      throw std::runtime_error("Spec error on line " + lineNumber + ": missing attribute <" + r.first + ">");
+    }
+    if (!r.second.empty() && (r.second.find(attributesIt->second) == r.second.end()))
+    {
+      throw std::runtime_error("Spec error on line " + lineNumber + ": unexpected attribute value <" + attributesIt->second + "> in attribute <" + r.first + ">");
+    }
+  }
+  // check if all not required attributes or optional, and if there is a set of allowed values, check if the actual value is part of that set
+  for (auto const& a : attributes)
+  {
+    if (required.find(a.first) == required.end())
+    {
+      auto optionalIt = optional.find(a.first);
+      if (optionalIt == optional.end())
+      {
+        std::cerr << "warning: " << "Unknown attribute " + a.first + " in line " + lineNumber + "!" << std::endl;
+        continue;
+      }
+      if (!optionalIt->second.empty())
+      {
+        std::vector<std::string> values = tokenize(a.second, ',');
+        for (auto const& v : values)
+        {
+          if (optionalIt->second.find(v) == optionalIt->second.end())
+          {
+            throw std::runtime_error("Spec error on line " + lineNumber + ": unexpected attribute value <" + v + "> in attribute <" + a.first + ">");
+          }
+        }
+      }
+    }
+  }
+}
+
+void checkElements(std::vector<tinyxml2::XMLElement const*> const& elements, std::set<std::string> const& values)
+{
+  for (auto e : elements)
+  {
+    if (values.find(e->Value()) == values.end())
+    {
+      std::stringstream ss;
+      ss << e->GetLineNum();
+      std::string lineNumber = ss.str();
+      std::cerr << "warning: Unknown element in spec on line: " << lineNumber << " " << e->Value() << "!" << std::endl;
+    }
+  }
+}
+
+void checkEmptyElement(tinyxml2::XMLElement const* element)
+{
+  checkAttributes(getAttributes(element), element->GetLineNum(), {}, {});
+  checkElements(getChildElements(element), {});
+}
+
+void checkOrderedElements(std::vector<tinyxml2::XMLElement const*> const& elements, std::vector<std::string> const& values)
+{
+  for (size_t i = 0; i < elements.size(); i++)
+  {
+    std::stringstream ss;
+    ss << elements[i]->GetLineNum();
+    std::string lineNumber = ss.str();
+
+    if (values.size() <= i)
+    {
+      throw std::runtime_error("Spec error on line " + lineNumber + ": unexpected surplus element <" + elements[i]->Value() + ">");
+    }
+    if (values[i] != elements[i]->Value())
+    {
+      throw std::runtime_error("Spec error on line " + lineNumber + ": unexpected element <" + elements[i]->Value() + ">, expected <" + values[i] + ">");
+    }
+  }
+}
+
+std::string createEnumValueName(std::string const& name, std::string const& prefix, std::string const& postfix, bool bitmask, std::string const& tag)
+{
+  std::string result = "e" + toCamelCase(stripPostfix(stripPrefix(name, prefix), postfix));
+  if (bitmask)
+  {
+    size_t pos = result.find("Bit");
+    if (pos != std::string::npos)
+    {
+      result.erase(pos, 3);
+    }
+  }
+  if (!tag.empty() && (result.substr(result.length() - tag.length()) == toCamelCase(tag)))
+  {
+    result = result.substr(0, result.length() - tag.length()) + tag;
+  }
+  return result;
+}
+
+std::string determineCommandName(std::string const& vulkanCommandName, std::string const& firstArgumentType)
+{
+  std::string commandName(startLowerCase(stripPrefix(vulkanCommandName, "vk")));
+  std::string searchName = stripPrefix(firstArgumentType, "Vk");
+  size_t pos = commandName.find(searchName);
+  if ((pos == std::string::npos) && isupper(searchName[0]))
+  {
+    searchName[0] = static_cast<char>(tolower(searchName[0]));
+    pos = commandName.find(searchName);
+  }
+  if (pos != std::string::npos)
+  {
+    commandName.erase(pos, searchName.length());
+  }
+  else if ((searchName == "commandBuffer") && beginsWith(commandName, "cmd"))
+  {
+    commandName.erase(0, 3);
+    pos = 0;
+  }
+  if ((pos == 0) && isupper(commandName[0]))
+  {
+    commandName[0] = static_cast<char>(tolower(commandName[0]));
+  }
+  return commandName;
+}
+
+std::set<size_t> determineSkippedParams(size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices)
+{
+  std::set<size_t> skippedParams;
+
+  // the size-parameters of vector parameters are not explicitly used in the enhanced API
+  std::for_each(vectorParamIndices.begin(), vectorParamIndices.end(), [&skippedParams](std::pair<size_t, size_t> const& vp) { if (vp.second != INVALID_INDEX) skippedParams.insert(vp.second); });
+
+  // and the return parameter is also skipped
+  if (returnParamIndex != INVALID_INDEX)
+  {
+    skippedParams.insert(returnParamIndex);
+  }
+  return skippedParams;
+}
+
+bool determineStructureChaining(std::string const& structType, std::set<std::string> const& extendedStructs, std::map<std::string, std::string> const& structureAliases)
+{
+  bool isStructureChained = (extendedStructs.find(structType) != extendedStructs.end());
+  if (!isStructureChained)
+  {
+    auto aliasIt = structureAliases.find(structType);
+    if ((aliasIt != structureAliases.end()))
+    {
+      isStructureChained = (extendedStructs.find(aliasIt->second) != extendedStructs.end());
+    }
+  }
+  return isStructureChained;
+}
+
+void enterProtect(std::ostream &os, std::string const& protect)
+{
+  if (!protect.empty())
+  {
+    os << "#ifdef " << protect << std::endl;
+  }
+}
+
+std::map<std::string, std::string> getAttributes(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes;
+  for (auto attribute = element->FirstAttribute(); attribute; attribute = attribute->Next())
+  {
+    assert(attributes.find(attribute->Name()) == attributes.end());
+    attributes[attribute->Name()] = attribute->Value();
+  }
+  return attributes;
+}
+
+std::vector<tinyxml2::XMLElement const*> getChildElements(tinyxml2::XMLElement const* element)
+{
+  std::vector<tinyxml2::XMLElement const*> childElements;
+  for (tinyxml2::XMLElement const* childElement = element->FirstChildElement(); childElement; childElement = childElement->NextSiblingElement())
+  {
+    childElements.push_back(childElement);
+  }
+  return childElements;
+}
+
+std::string getEnumPostfix(std::string const& name, std::set<std::string> const& tags, std::string & prefix)
+{
+  std::string postfix;
+  if (name != "VkResult")
+  {
+    // if the enum name contains a tag move it from the prefix to the postfix to generate correct enum value names.
+    for (auto const& tag : tags)
+    {
+      if (endsWith(prefix, tag + "_"))
+      {
+        prefix.erase(prefix.length() - tag.length() - 1);
+        postfix = "_" + tag;
+        break;
+      }
+      else if (endsWith(name, tag))
+      {
+        postfix = "_" + tag;
+        break;
+      }
+    }
+  }
+  return postfix;
+}
+
+std::string getEnumPrefix(std::string const& name, bool bitmask)
+{
+  std::string prefix;
+  if (name == "VkResult")
+  {
+    prefix = "VK_";
+  }
+  else if (bitmask)
+  {
+    // for a bitmask enum, start with "VK", cut off the trailing "FlagBits", and convert that name to upper case
+    // end that with "Bit"
+    size_t pos = name.find("FlagBits");
+    assert(pos != std::string::npos);
+    prefix = toUpperCase(name.substr(0, pos)) + "_";
+  }
+  else
+  {
+    // for a non-bitmask enum, convert the name to upper case
+    prefix = toUpperCase(name) + "_";
+  }
+  return prefix;
+}
+
+std::string extractTag(std::string const& name, std::set<std::string> const& tags)
+{
+  // extract the tag from the name, which is supposed to look like VK_<tag>_<other>
+  size_t tagStart = name.find('_');
+  assert(tagStart != std::string::npos);
+  size_t tagEnd = name.find('_', tagStart + 1);
+  assert(tagEnd != std::string::npos);
+  std::string tag = name.substr(tagStart + 1, tagEnd - tagStart - 1);
+  assert(tags.find(tag) != tags.end());
+  return tag;
+}
+
+void leaveProtect(std::ostream &os, std::string const& protect)
+{
+  if (!protect.empty())
+  {
+    os << "#endif /*" << protect << "*/" << std::endl;
+  }
+}
+
+std::string readArraySize(tinyxml2::XMLNode const* node, std::string& name)
+{
+  std::string arraySize;
+  if (name.back() == ']')
+  {
+    // if the parameter has '[' and ']' in its name, get the stuff inbetween those as the array size and erase that part from the parameter name
+    assert(!node->NextSibling());
+    size_t pos = name.find('[');
+    assert(pos != std::string::npos);
+    arraySize = name.substr(pos + 1, name.length() - 2 - pos);
+    name.erase(pos);
+  }
+  else
+  {
+    // otherwise look for a sibling of this node
+    node = node->NextSibling();
+    if (node && node->ToText())
+    {
+      assert(node->Value());
+      std::string value = trimEnd(node->Value());
+      if (value == "[")
+      {
+        // if this node has '[' as its value, the next node holds the array size, and the node after that needs to hold ']', and there should be no more siblings
+        node = node->NextSibling();
+        assert(node && node->ToElement() && (strcmp(node->Value(), "enum") == 0));
+        arraySize = node->ToElement()->GetText();
+        node = node->NextSibling();
+        assert(node && node->ToText() && (trimEnd(node->Value()) == "]"));
+      }
+      else
+      {
+        // otherwise, the node holds '[' and ']', so get the stuff in between those as the array size
+        assert((value.front() == '[') && (value.back() == ']'));
+        arraySize = value.substr(1, value.length() - 2);
+      }
+      assert(!node->NextSibling() || ((strcmp(node->NextSibling()->Value(), "comment") == 0) && !node->NextSibling()->NextSibling()));
+    }
+  }
+  return arraySize;
+}
+
+void readStructStructExtends(std::map<std::string, std::string> const& attributes, std::vector<std::string> & structExtends, std::set<std::string> & extendedStructs)
+{
+  auto attributesIt = attributes.find("structextends");
+  if (attributesIt != attributes.end())
+  {
+    std::vector<std::string> extends = tokenize(attributesIt->second, ',');
+    structExtends.insert(structExtends.end(), extends.begin(), extends.end());
+    extendedStructs.insert(extends.begin(), extends.end());
+    assert(!structExtends.empty());
+  }
+}
+
+std::string replaceWithMap(std::string const &input, std::map<std::string, std::string> replacements)
+{
+  // This will match ${someVariable} and contain someVariable in match group 1
+  std::regex re(R"(\$\{([^\}]+)\})");
+  auto it = std::sregex_iterator(input.begin(), input.end(), re);
+  auto end = std::sregex_iterator();
+
+  // No match, just return the original string
+  if (it == end)
+  {
+    return input;
+  }
+
+  std::string result = "";
+  while (it != end)
+  {
+    std::smatch match = *it;
+    auto itReplacement = replacements.find(match[1].str());
+    assert(itReplacement != replacements.end());
+
+    result += match.prefix().str() + ((itReplacement != replacements.end()) ? itReplacement->second : match[0].str());
+    ++it;
+
+    // we've passed the last match. Append the rest of the orignal string
+    if (it == end)
+    {
+      result += match.suffix().str();
+    }
+  }
+  return result;
+}
+
+std::string startLowerCase(std::string const& input)
+{
+  return input.empty() ? "" : static_cast<char>(tolower(input[0])) + input.substr(1);
+}
+
+std::string startUpperCase(std::string const& input)
+{
+  return input.empty() ? "" : static_cast<char>(toupper(input[0])) + input.substr(1);
+}
+
+std::string stripPostfix(std::string const& value, std::string const& postfix)
+{
+  std::string strippedValue = value;
+  if (endsWith(strippedValue, postfix))
+  {
+    strippedValue.erase(strippedValue.length() - postfix.length());
+  }
+  return strippedValue;
+}
+
+std::string stripPluralS(std::string const& name)
+{
+  std::string strippedName(name);
+  size_t pos = strippedName.rfind('s');
+  assert(pos != std::string::npos);
+  strippedName.erase(pos, 1);
+  return strippedName;
+}
+
+std::string stripPrefix(std::string const& value, std::string const& prefix)
+{
+  std::string strippedValue = value;
+  if (beginsWith(strippedValue, prefix))
+  {
+    strippedValue.erase(0, prefix.length());
+  }
+  return strippedValue;
+}
+
+std::string writeReinterpretCast(bool leadingConst, std::string const& type, bool trailingPointerToConst)
+{
+  std::string reinterpretCast = "reinterpret_cast<";
+  if (leadingConst)
+  {
+    reinterpretCast += "const ";
+  }
+  reinterpretCast += type;
+  if (trailingPointerToConst)
+  {
+    reinterpretCast += "* const";
+  }
+  reinterpretCast += "*>";
+  return reinterpretCast;
+}
+
+std::string toCamelCase(std::string const& value)
+{
+  assert(!value.empty() && (isupper(value[0]) || isdigit(value[0])));
+  std::string result;
+  result.reserve(value.size());
+  bool keepUpper = true;
+  for (auto c : value)
+  {
+    if (c == '_')
+    {
+      keepUpper = true;
+    }
+    else if (isdigit(c))
+    {
+      keepUpper = true;
+      result.push_back(c);
+    }
+    else if (keepUpper)
+    {
+      result.push_back(c);
+      keepUpper = false;
+    }
+    else
+    {
+      result.push_back(static_cast<char>(tolower(c)));
+    }
+  }
+  return result;
+}
+
+std::string toUpperCase(std::string const& name)
+{
+  std::string convertedName;
+  convertedName.reserve(name.size());
+
+  bool lowerOrDigit = false;
+  for (auto c : name)
+  {
+    if (islower(c) || isdigit(c))
+    {
+      lowerOrDigit = true;
+    }
+    else if (lowerOrDigit)
+    {
+      convertedName.push_back('_');
+      lowerOrDigit = false;
+    }
+    convertedName.push_back(static_cast<char>(toupper(c)));
+  }
+
+  return convertedName;
+}
+
+std::vector<std::string> tokenize(std::string tokenString, char separator)
+{
+  std::vector<std::string> tokens;
+  size_t start = 0, end;
+  do
+  {
+    end = tokenString.find(separator, start);
+    tokens.push_back(tokenString.substr(start, end - start));
+    start = end + 1;
+  } while (end != std::string::npos);
+  return tokens;
+}
+
+std::string trim(std::string const& input)
+{
+  std::string result = input;
+  result.erase(result.begin(), std::find_if(result.begin(), result.end(), [](char c) { return !std::isspace(c); }));
+  result.erase(std::find_if(result.rbegin(), result.rend(), [](char c) { return !std::isspace(c); }).base(), result.end());
+  return result;
+}
+
+std::string trimEnd(std::string const& input)
+{
+  std::string result = input;
+  result.erase(std::find_if(result.rbegin(), result.rend(), [](char c) { return !std::isspace(c); }).base(), result.end());
+  return result;
+}
+
+void writeArgumentCount(std::ostream & os, size_t vectorIndex, std::string const& vectorName, std::string const& counterName, size_t returnParamIndex, size_t templateParamIndex, bool twoStep, bool singular)
+{
+  // this parameter is a count parameter for a vector parameter
+  if ((returnParamIndex == vectorIndex) && twoStep)
+  {
+    // the corresponding vector parameter is the return parameter and it's a two-step algorithm
+    // -> use the pointer to a local variable named like the counter parameter without leading 'p'
+    assert((counterName[0] == 'p') && isupper(counterName[1]));
+    os << "&" << startLowerCase(stripPrefix(counterName, "p"));
+  }
+  else
+  {
+    // the corresponding vector parameter is not the return parameter, or it's not a two-step algorithm
+    if (singular)
+    {
+      // for the singular version, the count is just 1.
+      os << "1 ";
+    }
+    else
+    {
+      // for the non-singular version, the count is the size of the vector parameter
+      // -> use the vector parameter name without leading 'p' to get the size (in number of elements, not in bytes)
+      assert(vectorName[0] == 'p');
+      os << startLowerCase(stripPrefix(vectorName, "p")) << ".size() ";
+    }
+    if (templateParamIndex == vectorIndex)
+    {
+      // if the vector parameter is templatized -> multiply by the size of that type to get the size in bytes
+      os << "* sizeof( T ) ";
+    }
+  }
+}
+
+void writeBitmask(std::ostream & os, std::string const& bitmaskName, std::string const& bitmaskAlias, std::string const& enumName, std::vector<std::pair<std::string, std::string>> const& enumValues)
+{
+  // each Flags class is using the class 'Flags' with the corresponding FlagBits enum as the template parameter
+  os << std::endl
+    << "  using " << bitmaskName << " = Flags<" << enumName << ", Vk" << bitmaskName << ">;" << std::endl;
+
+  if (!enumValues.empty())
+  {
+    std::string allFlags;
+    for (auto const& value : enumValues)
+    {
+      if (!allFlags.empty())
+      {
+        allFlags += " | ";
+      }
+      allFlags += "VkFlags(" + enumName + "::" + value.second + ")";
+    }
+
+    static const std::string bitmaskOperatorsTemplate = R"(
+  VULKAN_HPP_INLINE ${bitmaskName} operator|( ${enumName} bit0, ${enumName} bit1 )
+  {
+    return ${bitmaskName}( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ${bitmaskName} operator~( ${enumName} bits )
+  {
+    return ~( ${bitmaskName}( bits ) );
+  }
+
+  template <> struct FlagTraits<${enumName}>
+  {
+    enum
+    {
+      allFlags = ${allFlags}
+    };
+  };
 )";
 
-const std::string constExprHeader = R"(
-#if defined(_MSC_VER) && (_MSC_VER <= 1800)
-# define VULKAN_HPP_CONSTEXPR
+    os << replaceWithMap(bitmaskOperatorsTemplate, { { "bitmaskName", bitmaskName },{ "enumName", enumName },{ "allFlags", allFlags } });
+  }
+
+  if (!bitmaskAlias.empty())
+  {
+    os << std::endl
+      << "  using " << stripPrefix(bitmaskAlias, "Vk") << " = " << bitmaskName << ";" << std::endl;
+  }
+}
+
+void writeBitmaskToStringFunction(std::ostream & os, std::string const& bitmaskName, std::string const& enumName, std::vector<std::pair<std::string, std::string>> const& enumValues)
+{
+  std::string functionBody;
+  if (enumValues.empty())
+  {
+    functionBody = "\n    return \"{}\";";
+  }
+  else
+  {
+    // 'or' together all the bits in the value
+    static const std::string caseTemplate = R"(
+    if ( value & ${typeName}::${value} ) result += "${valueString})";
+
+    std::string casesString;
+    for (auto const& value : enumValues)
+    {
+      if (!casesString.empty())
+      {
+        casesString += " | \";";
+      }
+      casesString += replaceWithMap(caseTemplate, { { "typeName", enumName },{ "value", value.second },{ "valueString", value.second.substr(1) } });
+    }
+    casesString += "\";";
+
+    static const std::string bodyTemplate = R"(
+    if ( !value ) return "{}";
+    std::string result;
+${cases})";
+    functionBody = replaceWithMap(bodyTemplate, { { "cases", casesString } });
+  }
+
+  static const std::string toStringTemplate = R"(
+  VULKAN_HPP_INLINE std::string to_string( ${typeName}${argumentName} )
+  {${functionBody}
+  }
+)";
+  os << replaceWithMap(toStringTemplate, { { "typeName", bitmaskName },{ "argumentName", enumValues.empty() ? " " : " value " },{ "functionBody", functionBody } });
+}
+
+void writeEnumToString(std::ostream & os, std::string const& enumName, std::vector<std::pair<std::string, std::string>> const& enumValues)
+{
+  std::string functionBody;
+  if (enumValues.empty())
+  {
+    functionBody = "\n    return \"(void)\";";
+  }
+  else
+  {
+    static const std::string caseTemplate = R"(      case ${type}::${value} : return "${valueText}";)";
+    std::ostringstream casesString;
+    for (auto const& value : enumValues)
+    {
+      casesString << replaceWithMap(caseTemplate, { { "type", enumName },{ "value", value.second },{ "valueText", value.second.substr(1) } }) << std::endl;
+    }
+
+    static const std::string switchTemplate = R"(
+    switch ( value )
+    {
+${cases}      default: return "invalid";
+    })";
+    functionBody = replaceWithMap(switchTemplate, { { "cases", casesString.str() } });
+  }
+
+  static const std::string enumToString = R"(
+  VULKAN_HPP_INLINE std::string to_string( ${typeName}${argumentName} )
+  {${functionBody}
+  }
+)";
+  os << replaceWithMap(enumToString,
+  {
+    { "typeName", enumName },
+    { "argumentName", enumValues.empty() ? "" : " value" },
+    { "functionBody", functionBody }
+  });
+}
+
+std::string writeFunctionBodyEnhancedLocalReturnVariableSingular(std::ostream & os, std::string const& indentation, std::string const& typeName, std::string const& returnName, bool isStructureChain)
+{
+  std::string adjustedReturnName = stripPluralS(returnName);
+  if (isStructureChain)
+  {
+    // For StructureChains use the template parameters
+    os << "StructureChain<X, Y, Z...> structureChain;" << std::endl;
+    os << indentation << "  " << typeName << "& " << adjustedReturnName << " = structureChain.template get<" << typeName << ">()";
+    adjustedReturnName = "structureChain";
+  }
+  else
+  {
+    // in singular case, just use the return parameters pure type for the return variable
+    os << typeName << " " << adjustedReturnName;
+  }
+  return adjustedReturnName;
+}
+
+std::pair<bool, std::string> writeFunctionBodyStandardReturn(std::string const& returnType)
+{
+  bool castReturn = false;
+  std::string ret;
+  if (returnType != "void")
+  {
+    // there's something to return...
+    ret = "return ";
+
+    castReturn = beginsWith(returnType, "Vk");
+    if (castReturn)
+    {
+      // the return-type is a vulkan type -> need to cast to vk::-type
+      ret += "static_cast<" + stripPrefix(returnType, "Vk") + ">( ";
+    }
+  }
+  return std::make_pair(castReturn, ret);
+}
+
+bool VulkanHppGenerator::containsUnion(std::string const& type) const
+{
+  // a simple recursive check if a type is or contains a union
+  auto structureIt = m_structures.find(type);
+  bool found = (structureIt != m_structures.end());
+  if (found)
+  {
+    found = structureIt->second.isUnion;
+    for (auto memberIt = structureIt->second.members.begin(); memberIt != structureIt->second.members.end() && !found; ++memberIt)
+    {
+      found = memberIt->type.prefix.empty() && memberIt->type.postfix.empty() && containsUnion(memberIt->type.type);
+    }
+  }
+  return found;
+}
+
+void VulkanHppGenerator::checkCorrectness()
+{
+  for (auto const& handle : m_handles)
+  {
+    for (auto const& command: handle.second.commands)
+    {
+      // check that functions returning a VkResult specify successcodes
+      if ((command.second.returnType == "VkResult") && command.second.successCodes.empty())
+      {
+        throw std::runtime_error("Spec error on command Vk" + startUpperCase(command.first) + " : missing successcodes on command returning VkResult!");
+      }
+    }
+  }
+}
+
+std::string VulkanHppGenerator::defaultValue(std::string const& type) const
+{
+  if (beginsWith(type, "PFN_vk") || (type == "LPCWSTR"))
+  {
+    return "nullptr";
+  }
+  else if (beginsWith(type, "Vk"))
+  {
+    auto const baseTypeIt = m_baseTypes.find(type);
+    if (baseTypeIt != m_baseTypes.end())
+    {
+      return "0";
+    }
+    else
+    {
+      auto const& bitmaskBitIt = m_bitmaskBits.find(type);
+      if (bitmaskBitIt != m_bitmaskBits.end())
+      {
+        return stripPrefix(type, "Vk") + (bitmaskBitIt->second.values.empty() ? "()" : ("::" + bitmaskBitIt->second.values.front().second));
+      }
+      else
+      {
+        auto const& enumIt = m_enums.find(type);
+        if (enumIt != m_enums.end())
+        {
+          return stripPrefix(type, "Vk") + (enumIt->second.values.empty() ? "()" : ("::" + enumIt->second.values.front().second));
+        }
+        else
+        {
+          assert((m_bitmasks.find(type) != m_bitmasks.end()) || (m_handles.find(type) != m_handles.end()) || (m_structures.find(type) != m_structures.end()));
+          return stripPrefix(type, "Vk") + "()";
+        }
+      }
+    }
+  }
+  else
+  {
+#if !defined(NDEBUG)
+    static const std::set<std::string> otherTypes =
+    {
+      "DWORD", "float", "HANDLE", "HINSTANCE", "HWND", "int", "int32_t", "size_t", "uint32_t", "uint64_t", "uint8_t", "Window", "xcb_window_t", "zx_handle_t"
+    };
+    assert(otherTypes.find(type) != otherTypes.end());
+#endif
+    return "0";
+  }
+}
+
+std::string VulkanHppGenerator::determineEnhancedReturnType(CommandData const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool isStructureChain) const
+{
+  assert((returnParamIndex == INVALID_INDEX) || (returnParamIndex < commandData.params.size()));
+  for (auto vpi : vectorParamIndices)
+  {
+    assert((vpi.first != vpi.second) && (vpi.first < commandData.params.size()) && ((vpi.second == INVALID_INDEX) || (vpi.second < commandData.params.size())));
+  }
+
+  std::string enhancedReturnType;
+  // if there is a return parameter of type void or Result, and if it's of type Result it either has just one success code
+  // or two success codes, where the second one is of type eIncomplete and it's a two-step process
+  // -> we can return that parameter
+  if ((returnParamIndex != INVALID_INDEX)
+    && ((commandData.returnType == "void")
+      || ((commandData.returnType == "VkResult")
+        && ((commandData.successCodes.size() == 1)
+          || ((commandData.successCodes.size() == 2)
+            && (commandData.successCodes[1] == "eIncomplete")
+            && twoStep)))))
+  {
+    if (vectorParamIndices.find(returnParamIndex) != vectorParamIndices.end())
+    {
+      enhancedReturnType = (commandData.params[returnParamIndex].type.type == "void")
+        ? "std::vector<uint8_t,Allocator>"                                                                      // the return parameter is a vector-type parameter
+        : isStructureChain
+          ? "std::vector<StructureChain,Allocator>"                                                             // for structureChain returns, it's just a vector of StrutureChains
+          : "std::vector<" + stripPrefix(commandData.params[returnParamIndex].type.type, "Vk") + ",Allocator>"; // for the other parameters, we use a vector of the pure type
+    }
+    else
+    {
+      // it's a simple parameter -> get the type and just remove the trailing '*' (originally, it's a pointer)
+      assert(commandData.params[returnParamIndex].type.postfix.back() == '*');
+      assert((commandData.params[returnParamIndex].type.prefix.find("const") == std::string::npos) && (commandData.params[returnParamIndex].type.postfix.find("const") == std::string::npos));
+      enhancedReturnType = stripPostfix(commandData.params[returnParamIndex].type.compose(), "*");
+    }
+  }
+  else if ((commandData.returnType == "VkResult") && (commandData.successCodes.size() == 1))
+  {
+    // an original return of type "Result" with just one successCode is changed to void, errors throw an exception
+    enhancedReturnType = "void";
+  }
+  else
+  {
+    // the return type just stays the original return type
+    enhancedReturnType = stripPrefix(commandData.returnType, "Vk");
+  }
+  return enhancedReturnType;
+}
+
+size_t VulkanHppGenerator::determineReturnParamIndex(CommandData const& commandData, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep) const
+{
+  for (auto vpi : vectorParamIndices)
+  {
+    assert((vpi.first != vpi.second) && (vpi.first < commandData.params.size()) && ((vpi.second == INVALID_INDEX) || (vpi.second < commandData.params.size())));
+  }
+
+  size_t returnParamIndex = INVALID_INDEX;
+  // for return types of type VkResult or void, we can determine a parameter to return
+  if ((commandData.returnType == "VkResult") || (commandData.returnType == "void"))
+  {
+    for (size_t i = 0; i < commandData.params.size(); i++)
+    {
+      if ((commandData.params[i].type.postfix.find('*') != std::string::npos)
+        && (commandData.params[i].type.prefix.find("const") == std::string::npos)
+        && std::find_if(vectorParamIndices.begin(), vectorParamIndices.end(), [i](std::pair<size_t, size_t> const& vpi) { return vpi.second == i; }) == vectorParamIndices.end())
+      {
+        // it's a non-const pointer and not a vector-size parameter
+        std::map<size_t, size_t>::const_iterator vpit = vectorParamIndices.find(i);
+        if ((vpit == vectorParamIndices.end()) || twoStep || (vectorParamIndices.size() > 1) || (vpit->second == INVALID_INDEX) || (commandData.params[vpit->second].type.postfix.find('*') != std::string::npos))
+        {
+          // it's not a vector parameter, or a two-step process, or there is at least one more vector parameter, or the size argument of this vector parameter is not an argument, or the size argument of this vector parameter is provided by a pointer
+          // -> look for another non-cost pointer argument
+          auto paramIt = std::find_if(commandData.params.begin() + i + 1, commandData.params.end(), [](ParamData const& pd)
+          {
+            return (pd.type.postfix.find('*') != std::string::npos) && (pd.type.postfix.find("const") == std::string::npos);
+          });
+          // if there is another such argument, we can't decide which one to return -> return INVALID_INDEX
+          // otherwise return the index of the selcted parameter
+          returnParamIndex = paramIt != commandData.params.end() ? INVALID_INDEX : i;
+        }
+      }
+    }
+  }
+  return returnParamIndex;
+}
+
+std::string VulkanHppGenerator::determineSubStruct(std::pair<std::string, StructureData> const& structure) const
+{
+  for (auto const& s : m_structures)
+  {
+    if ((s.first != structure.first) && (s.second.members.size() < structure.second.members.size()) && (s.second.members[0].name != "sType"))
+    {
+      bool equal = true;
+      for (size_t i = 0; i < s.second.members.size() && equal; i++)
+      {
+        equal = (s.second.members[i].type == structure.second.members[i].type) && (s.second.members[i].name == structure.second.members[i].name);
+      }
+      if (equal)
+      {
+        return s.first;
+      }
+    }
+  }
+  return "";
+}
+
+size_t VulkanHppGenerator::determineTemplateParamIndex(std::vector<ParamData> const& params, std::map<size_t, size_t> const& vectorParamIndices) const
+{
+  size_t templateParamIndex = INVALID_INDEX;
+
+  for (size_t i = 0; i < params.size(); i++)
+  {
+    // any vector parameter on the pure type void is templatized in the enhanced API
+    if ((vectorParamIndices.find(i) != vectorParamIndices.end()) && (params[i].type.type == "void"))
+    {
+#if !defined(NDEBUG)
+      for (size_t j = i + 1; j < params.size(); j++)
+      {
+        assert((vectorParamIndices.find(j) == vectorParamIndices.end()) || (params[j].type.type != "void"));
+      }
+#endif
+      templateParamIndex = i;
+      break;
+    }
+  }
+  assert((templateParamIndex == INVALID_INDEX) || (vectorParamIndices.find(templateParamIndex) != vectorParamIndices.end()));
+  return templateParamIndex;
+}
+
+std::map<size_t, size_t> VulkanHppGenerator::determineVectorParamIndices(std::vector<ParamData> const& params) const
+{
+  std::map<size_t, size_t> vectorParamIndices;
+
+  // look for the parameters whose len equals the name of an other parameter
+  for (auto it = params.begin(); it != params.end(); ++it)
+  {
+    if (!it->len.empty())
+    {
+      auto findLambda = [it](ParamData const& pd) { return pd.name == it->len; };
+      auto findIt = std::find_if(params.begin(), it, findLambda);                        // look for a parameter named as the len of this parameter
+      assert((std::count_if(params.begin(), params.end(), findLambda) == 0) || (findIt < it));    // make sure, there is no other parameter like that
+
+      // add this parameter as a vector parameter, using the len-name parameter as the second value (or INVALID_INDEX if there is nothing like that)
+      vectorParamIndices.insert(std::make_pair(std::distance(params.begin(), it), (findIt < it) ? std::distance(params.begin(), findIt) : INVALID_INDEX));
+      assert((vectorParamIndices[std::distance(params.begin(), it)] != INVALID_INDEX)
+        || (it->len == "null-terminated")
+        || (it->len == "pAllocateInfo::descriptorSetCount")
+        || (it->len == "pAllocateInfo::commandBufferCount"));
+    }
+  }
+  return vectorParamIndices;
+}
+
+std::string VulkanHppGenerator::generateCall(std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool firstCall, bool singular) const
+{
+  std::ostringstream call;
+
+  // the original function call
+  call << "d." << commandData.first << "( ";
+
+  assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
+  std::string const& handle = m_commandToHandle.find(commandData.first)->second;
+  if (!handle.empty())
+  {
+    // if it's member of a class -> the first argument is the member variable, starting with "m_"
+    assert(handle == commandData.second.params[0].type.type);
+    call << "m_" << startLowerCase(stripPrefix(handle, "Vk"));
+    if (1 < commandData.second.params.size())
+    {
+      call << ", ";
+    }
+  }
+
+  writeArguments(call, commandData.second, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, firstCall, singular, handle.empty() ? 0 : 1, commandData.second.params.size());
+  call << " )";
+  return call.str();
+}
+
+std::set<std::string> VulkanHppGenerator::gatherForwardDeclarations()
+{
+  // all structures in command parameters need to be forward declared
+  std::set<std::string> forwardDeclarations;
+  for (auto const& handle : m_handles)
+  {
+    for (auto const& command : handle.second.commands)
+    {
+      for (auto const& parameter : command.second.params)
+      {
+        auto structureIt = m_structures.find(parameter.type.type);
+        if (structureIt != m_structures.end())
+        {
+          forwardDeclarations.insert(parameter.type.type);
+        }
+      }
+    }
+  }
+  return forwardDeclarations;
+}
+
+std::string const& VulkanHppGenerator::getTypesafeCheck() const
+{
+  return m_typesafeCheck;
+}
+
+std::string const& VulkanHppGenerator::getVersion() const
+{
+  return m_version;
+}
+
+std::string const& VulkanHppGenerator::getVulkanLicenseHeader() const
+{
+  return m_vulkanLicenseHeader;
+}
+
+bool VulkanHppGenerator::isTwoStepAlgorithm(std::vector<ParamData> const& params) const
+{
+  // we generate a two-step algorithm for functions returning a vector of stuff, where the length is specified as a pointer as well
+  // for those functions, the size can be queried first, and then used
+  bool isTwoStep = false;
+  for (auto paramIt = params.begin(); paramIt != params.end() && !isTwoStep; ++paramIt)
+  {
+    if (!paramIt->len.empty())
+    {
+      auto lenIt = std::find_if(params.begin(), paramIt, [paramIt](ParamData const& pd) { return paramIt->len == pd.name; });
+      if (lenIt != paramIt)
+      {
+        isTwoStep = (lenIt->type.postfix.find('*') != std::string::npos);
+      }
+    }
+  }
+  return isTwoStep;
+}
+
+void VulkanHppGenerator::linkCommandToHandle(std::string const& name, CommandData const& commandData)
+{
+  // first, find the handle named like the type of the first argument
+  // if there is no such handle, look for the unnamed "handle", that gathers all the functions not tied to a specific handle
+  assert(!commandData.params.empty());
+  std::map<std::string, HandleData>::iterator handleIt = m_handles.find(commandData.params[0].type.type);
+  if (handleIt == m_handles.end())
+  {
+    handleIt = m_handles.find("");
+  }
+  assert(handleIt != m_handles.end());
+
+  // put the command into the handle's list of commands
+  assert(handleIt->second.commands.find(name) == handleIt->second.commands.end());
+  handleIt->second.commands[name] = commandData;
+
+  // and store the handle in the command-to-handle map
+  assert(m_commandToHandle.find(name) == m_commandToHandle.end());
+  m_commandToHandle[name] = handleIt->first;
+}
+
+void VulkanHppGenerator::readBaseType(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes)
+{
+  checkAttributes(attributes, element->GetLineNum(), { { "category",{ "basetype" } } }, {});
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkOrderedElements(children, { "type", "name" });
+  checkEmptyElement(children[0]);
+  checkEmptyElement(children[1]);
+
+  std::string type = children[0]->GetText();
+  std::string name = children[1]->GetText();
+#if !defined(NDEBUG)
+  assert((type == "uint32_t") || (type == "uint64_t"));
+#endif
+
+  assert(m_baseTypes.find(name) == m_baseTypes.end());
+  m_baseTypes[name] = type;
+}
+
+void VulkanHppGenerator::readBitmask(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes)
+{
+  checkAttributes(attributes, element->GetLineNum(), { { "category",{ "bitmask" } } }, { { "alias",{} },{ "name",{} },{ "requires",{} } });
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+
+  auto aliasIt = attributes.find("alias");
+  if (aliasIt != attributes.end())
+  {
+    readBitmaskAlias(element->GetLineNum(), aliasIt->second, attributes, children);
+  }
+  else
+  {
+    checkOrderedElements(children, { "type", "name" });
+    checkEmptyElement(children[0]);
+    checkEmptyElement(children[1]);
+
+    assert(strcmp(children[0]->GetText(), "VkFlags") == 0);
+
+    std::string name = children[1]->GetText();
+
+    std::string requires;
+    auto requiresIt = attributes.find("requires");
+    if (requiresIt != attributes.end())
+    {
+      requires = requiresIt->second;
+    }
+    else
+    {
+      // Generate FlagBits name and add it to the list of enums and vulkan types
+      requires = name;
+      size_t pos = requires.rfind("Flags");
+      assert(pos != std::string::npos);
+      requires.replace(pos, 5, "FlagBits");
+
+      assert(m_bitmaskBits.find(requires) == m_bitmaskBits.end());
+      m_bitmaskBits.insert(std::make_pair(requires, EnumData()));
+    }
+
+    m_bitmasks.insert(std::make_pair(name, BitmaskData(requires)));
+  }
+}
+
+void VulkanHppGenerator::readBitmaskAlias(int lineNum, std::string const& alias, std::map<std::string, std::string> const& attributes, std::vector<tinyxml2::XMLElement const*> const& children)
+{
+  checkAttributes(attributes, lineNum, { { "alias",{} },{ "category",{ "bitmask" } },{ "name",{} } }, {});   // re-check on alias type!
+  checkElements(children, {});
+
+  checkAlias(m_bitmasks, alias, lineNum);
+
+  auto bitmasksIt = m_bitmasks.find(alias);
+  assert((bitmasksIt != m_bitmasks.end()) && bitmasksIt->second.alias.empty());
+  bitmasksIt->second.alias = attributes.find("name")->second;
+}
+
+void VulkanHppGenerator::readCommand(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), {},
+  {
+    { "alias",{} },
+    { "cmdbufferlevel",{ "primary", "secondary" } },
+    { "comment",{} },
+    { "errorcodes",{} },
+    { "name",{} },
+    { "pipeline",{ "compute", "graphics", "transfer" } },
+    { "queues",{ "compute", "graphics", "sparse_binding", "transfer" } },
+    { "renderpass",{ "both", "inside", "outside" } },
+    { "successcodes",{} }
+  });
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+
+  std::string name;
+  CommandData commandData;
+  auto aliasIt = attributes.find("alias");
+  if (aliasIt != attributes.end())
+  {
+    readCommandAlias(element->GetLineNum(), aliasIt->second, attributes, children);
+  }
+  else
+  {
+    checkElements(children, { "implicitexternsyncparams", "param", "proto" });
+
+    commandData.successCodes = readCommandSuccessCodes(attributes);
+
+    for (auto child : children)
+    {
+      std::string value = child->Value();
+      if (value == "param")
+      {
+        commandData.params.push_back(readCommandParam(child));
+      }
+      else if (value == "proto")
+      {
+        name = readCommandProto(child, commandData.returnType);
+      }
+    }
+
+    registerDeleter(name, std::make_pair(name, commandData));
+    linkCommandToHandle(name, commandData);
+  }
+}
+
+void VulkanHppGenerator::readCommandAlias(int lineNum, std::string const& alias, std::map<std::string, std::string> const& attributes, std::vector<tinyxml2::XMLElement const*> const& children)
+{
+  // for command aliases, create a copy of the aliased command
+  checkAttributes(attributes, lineNum, { { "alias",{} },{ "name",{} } }, {});    // re-check on alias type!
+  checkElements(children, {});
+
+  std::string name = attributes.find("name")->second;
+  checkAlias(m_commandToHandle, alias, lineNum);
+  auto handleIt = m_handles.find(m_commandToHandle.find(alias)->second);
+  assert(handleIt != m_handles.end());
+  auto commandsIt = handleIt->second.commands.find(alias);
+  assert(commandsIt != handleIt->second.commands.end());
+
+  // create a copy of the found command, mark that as an alias and link it to a handle
+  CommandData commandData = commandsIt->second;
+  commandData.isAlias = true;
+  linkCommandToHandle(name, commandData);
+}
+
+VulkanHppGenerator::ParamData VulkanHppGenerator::readCommandParam(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), {}, { { "externsync",{} },{ "len",{} },{ "noautovalidity",{ "true" } },{ "optional",{ "false", "true" } } });
+  checkElements(getChildElements(element), { "name", "type" });
+
+  ParamData param;
+
+  auto lenAttribute = attributes.find("len");
+  if (lenAttribute != attributes.end())
+  {
+    param.len = lenAttribute->second;
+  }
+
+  // get the type of the parameter, and put it into the list of dependencies
+  tinyxml2::XMLNode const* child = readCommandParamType(element->FirstChild(), param);
+
+  assert(child->ToElement());
+  tinyxml2::XMLElement const* nameElement = child->ToElement();
+  checkEmptyElement(nameElement);
+  param.name = child->ToElement()->GetText();
+
+  param.arraySize = readArraySize(child, param.name);
+
+  auto optionalAttribute = attributes.find("optional");
+  param.optional = (optionalAttribute != attributes.end()) && (optionalAttribute->second == "true");
+
+  return param;
+}
+
+tinyxml2::XMLNode const* VulkanHppGenerator::readCommandParamType(tinyxml2::XMLNode const* node, ParamData& param)
+{
+  assert(node);
+  if (node->ToText())
+  {
+    // start type with "const" or "struct", if needed
+    std::string value = trim(node->Value());
+    assert((value == "const") || (value == "struct") || (value == "const struct"));
+    param.type.prefix = value;
+    node = node->NextSibling();
+    assert(node);
+  }
+
+  // get the pure type
+  assert(node->ToElement());
+  tinyxml2::XMLElement const* typeElement = node->ToElement();
+  checkEmptyElement(typeElement);
+
+  // replace aliased types by its alias
+  param.type.type = node->ToElement()->GetText();
+
+  // end with "*", "**", or "* const*", if needed
+  node = node->NextSibling();
+  assert(node);
+  if (node->ToText())
+  {
+    std::string value = trimEnd(node->Value());
+    assert((value == "*") || (value == "**") || (value == "* const*"));
+    param.type.postfix = value;
+    node = node->NextSibling();
+  }
+
+  return node;
+}
+
+std::string VulkanHppGenerator::readCommandProto(tinyxml2::XMLElement const* element, std::string & returnType)
+{
+  checkAttributes(getAttributes(element), element->GetLineNum(), {}, {});
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkOrderedElements(children, { "type", "name" });
+
+  // get return type and name of the command
+  returnType = children[0]->GetText();
+
+  // add an empty DependencyData to this name
+  std::string name = children[1]->GetText();
+  return name;
+}
+
+void VulkanHppGenerator::readCommands(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), {}, { { "comment",{} } });
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "command" });
+
+  for (auto child : children)
+  {
+    readCommand(child);
+  }
+}
+
+std::vector<std::string> VulkanHppGenerator::readCommandSuccessCodes(std::map<std::string, std::string> const& attributes)
+{
+  // read the success codes
+  std::vector<std::string> successCodes;
+  auto successcodesAttribute = attributes.find("successcodes");
+  if (successcodesAttribute != attributes.end())
+  {
+    successCodes = tokenize(successcodesAttribute->second, ',');
+    for (auto & code : successCodes)
+    {
+      // find the tag in the code
+      auto tagIt = std::find_if(m_tags.begin(), m_tags.end(), [&code](std::string const& t) { return endsWith(code, t); });
+      std::string tag = (tagIt != m_tags.end()) ? *tagIt : "";
+
+      // on each success code: prepend 'e', strip "VK_" and a tag, convert it to camel case, and add the tag again
+      code = std::string("e") + toCamelCase(stripPostfix(stripPrefix(code, "VK_"), tag)) + tag;
+    }
+  }
+  return successCodes;
+}
+
+void VulkanHppGenerator::readComment(tinyxml2::XMLElement const* element)
+{
+  checkAttributes(getAttributes(element), element->GetLineNum(), {}, {});
+  checkElements(getChildElements(element), {});
+
+  assert(element->GetText());
+  std::string text = element->GetText();
+  if (text.find("\nCopyright") == 0)
+  {
+    assert(m_vulkanLicenseHeader.empty());
+    m_vulkanLicenseHeader = text;
+
+    // replace any '\n' with "\n// "
+    for (size_t pos = m_vulkanLicenseHeader.find('\n'); pos != std::string::npos; pos = m_vulkanLicenseHeader.find('\n', pos + 1))
+    {
+      m_vulkanLicenseHeader.replace(pos, 1, "\n// ");
+    }
+
+    // and add a little message on our own
+    m_vulkanLicenseHeader += "\n\n// This header is generated from the Khronos Vulkan XML API Registry.";
+    m_vulkanLicenseHeader = trim(m_vulkanLicenseHeader);
+  }
+}
+
+void VulkanHppGenerator::readDefine(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes)
+{
+  checkAttributes(attributes, element->GetLineNum(), { { "category",{ "define" } } }, { { "name",{} } });
+
+  auto nameIt = attributes.find("name");
+  if (nameIt != attributes.end())
+  {
+    assert(!element->FirstChildElement());
+    assert(nameIt->second == "VK_DEFINE_NON_DISPATCHABLE_HANDLE");
+
+    // filter out the check for the different types of VK_DEFINE_NON_DISPATCHABLE_HANDLE
+    std::string text = element->LastChild()->ToText()->Value();
+    size_t start = text.find("#if defined(__LP64__)");
+    size_t end = text.find_first_of("\r\n", start + 1);
+    m_typesafeCheck = text.substr(start, end - start);
+  }
+  else if (element->GetText() && (trim(element->GetText()) == "struct"))
+  {
+#if !defined(NDEBUG)
+    tinyxml2::XMLElement const* child = element->FirstChildElement();
+    assert(child && (strcmp(child->Value(), "name") == 0) && child->GetText());
+    m_defines.insert(child->GetText());
+#endif
+  }
+  else
+  {
+    tinyxml2::XMLElement const* child = element->FirstChildElement();
+    assert(child && !child->FirstAttribute() && (strcmp(child->Value(), "name") == 0) && child->GetText());
+    std::string text = trim(child->GetText());
+    if (text == "VK_HEADER_VERSION")
+    {
+      m_version = trimEnd(element->LastChild()->ToText()->Value());
+    }
+    // ignore all the other defines
+    assert(!child->NextSiblingElement() || (child->NextSiblingElement() && !child->NextSiblingElement()->FirstAttribute() && (strcmp(child->NextSiblingElement()->Value(), "type") == 0) && !child->NextSiblingElement()->NextSiblingElement()));
+  }
+}
+
+void VulkanHppGenerator::readEnum(tinyxml2::XMLElement const* element, EnumData & enumData, bool bitmask, std::string const& prefix, std::string const& postfix)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), { { "name",{} } }, { { "alias",{} },{ "bitpos",{} },{ "comment",{} },{ "value",{} } });
+  assert((attributes.find("alias") != attributes.end()) + (attributes.find("bitpos") != attributes.end()) + (attributes.find("value") != attributes.end()) == 1);
+  checkElements(getChildElements(element), {});
+
+  std::string name = attributes.find("name")->second;
+  auto tagIt = std::find_if(m_tags.begin(), m_tags.end(), [&name, &postfix](std::string const& t) { return endsWith(name, t + postfix); });
+  std::string tag = (tagIt != m_tags.end()) ? *tagIt : "";
+
+  auto aliasIt = attributes.find("alias");
+  if (aliasIt != attributes.end())
+  {
+    auto enumIt = std::find_if(enumData.values.begin(), enumData.values.end(), [&aliasIt](std::pair<std::string, std::string> const& value) { return value.first == aliasIt->second; });
+    assert(enumIt != enumData.values.end());
+    enumData.aliases.push_back(std::make_pair(name, createEnumValueName(name, prefix, postfix, bitmask, tag)));
+  }
+  else
+  {
+    enumData.addEnumValue(name, bitmask, prefix, postfix, tag);
+  }
+}
+
+void VulkanHppGenerator::readEnums(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), { { "name",{} } }, { { "comment",{} },{ "type",{ "bitmask", "enum" } } });
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "comment", "enum", "unused" });
+
+  std::string name = attributes.find("name")->second;
+
+  if (name != "API Constants")
+  {
+    checkAttributes(attributes, element->GetLineNum(), { { "name",{} },{ "type",{ "bitmask", "enum" } } }, { { "comment",{} } });   // re-check with type as required
+
+    // ad an empty EnumData on this name into the enums map
+    EnumData enumData;
+    std::string type = attributes.find("type")->second;
+    bool bitmask = (type == "bitmask");
+    std::map<std::string, EnumData>::iterator it = bitmask ? m_bitmaskBits.insert(std::make_pair(name, enumData)).first : m_enums.insert(std::make_pair(name, enumData)).first;
+    assert(it->second.values.empty());
+
+    std::string prefix = getEnumPrefix(name, bitmask);
+    std::string postfix = getEnumPostfix(name, m_tags, prefix);
+    // read the names of the enum values
+    for (auto child : children)
+    {
+      std::string value = child->Value();
+      if (value == "enum")
+      {
+        readEnum(child, it->second, bitmask, prefix, postfix);
+      }
+#if !defined(NDEBUG)
+      else
+      {
+        assert((value == "comment") || (value == "unused"));
+      }
+#endif
+    }
+  }
+}
+
+void VulkanHppGenerator::readExtension(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(),
+  {
+    { "name",{} },
+    { "number",{} },
+    { "supported",{ "disabled", "vulkan" } }
+  },
+  {
+    { "author",{} },
+    { "comment",{} },
+    { "contact",{} },
+    { "deprecatedby",{} },
+    { "obsoletedby",{} },
+    { "platform",{} },
+    { "promotedto",{} },
+    { "provisional",{} },
+    { "requires",{} },
+    { "requiresCore",{} },
+    { "type",{ "device", "instance" } }
+  });
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "require" });
+
+  if (attributes.find("supported")->second == "disabled")
+  {
+    readExtensionDisabled(children);
+  }
+  else
+  {
+    std::string name = attributes.find("name")->second;
+    assert(beginsWith(name, "VK"));
+
+    std::string tag = extractTag(name, m_tags);
+
+    auto platformAttribute = attributes.find("platform");
+    std::string platform = (platformAttribute != attributes.end()) ? platformAttribute->second : "";
+    assert(platform.empty() || (m_platforms.find(platform) != m_platforms.end()));
+
+    for (auto child : children)
+    {
+      assert(strcmp(child->Value(), "require") == 0);
+      readExtensionRequire(child, platform, tag);
+    }
+  }
+}
+
+void VulkanHppGenerator::readExtensionDisabled(std::vector<tinyxml2::XMLElement const*> const& children)
+{
+  // kick out all the disabled stuff we've read before !!
+  for (auto const& child : children)
+  {
+    assert(strcmp(child->Value(), "require") == 0);
+    readExtensionDisabledRequire(child);
+  }
+}
+
+void VulkanHppGenerator::readExtensionDisabledRequire(tinyxml2::XMLElement const* element)
+{
+  checkAttributes(getAttributes(element), element->GetLineNum(), {}, {});
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "command", "enum", "type" });
+
+  for (auto child : children)
+  {
+    checkElements(getChildElements(child), {});
+
+    std::string value = child->Value();
+    if ((value == "command") || (value == "type"))
+    {
+      std::map<std::string, std::string> attributes = getAttributes(child);
+      checkAttributes(attributes, element->GetLineNum(), { { "name",{} } }, {});
+
+      // disable a command or a type !
+      auto nameAttribute = attributes.find("name");
+      std::string name = nameAttribute->second;
+      std::string strippedName = (value == "command") ? startLowerCase(stripPrefix(name, "vk")) : stripPrefix(name, "Vk");
+
+      if (value == "command")
+      {
+        // first unlink the command from its class
+        unlinkCommandFromHandle(name);
+
+        // then remove the command
+        m_commandToHandle.erase(name);
+      }
+      else
+      {
+        // a type simply needs to be removed from the structs and vkTypes sets
+        assert(m_structures.find(nameAttribute->second) != m_structures.end());
+        m_structures.erase(nameAttribute->second);
+      }
+    }
+    else
+    {
+      assert(value == "enum");
+      std::map<std::string, std::string> attributes = getAttributes(child);
+      checkAttributes(attributes, child->GetLineNum(), { { "name",{} } }, { { "bitpos",{} },{ "extends",{} },{ "offset",{} },{ "value",{} } });
+    }
+  }
+}
+
+void VulkanHppGenerator::readExtensionRequire(tinyxml2::XMLElement const* element, std::string const& platform, std::string const& tag)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), {}, { { "extension",{} },{ "feature",{} } });
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "command", "comment", "enum", "type" });
+
+  for (auto child : children)
+  {
+    std::string value = child->Value();
+
+    if (value == "command")
+    {
+      readExtensionRequireCommand(child, platform);
+    }
+    else if (value == "enum")
+    {
+      readExtensionRequireEnum(child, tag);
+    }
+    else if (value == "type")
+    {
+      readExtensionRequireType(child, platform);
+    }
+#if !defined(NDEBUG)
+    else
+    {
+      assert(value == "comment");
+      checkEmptyElement(child);
+    }
+#endif
+  }
+}
+
+void VulkanHppGenerator::readExtensionRequireCommand(tinyxml2::XMLElement const* element, std::string const& platform)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), { { "name",{} } }, {});
+  checkElements(getChildElements(element), {});
+
+  // just add the protect string to the CommandData
+  if (!platform.empty())
+  {
+    assert(m_platforms.find(platform) != m_platforms.end());
+    std::string name = attributes.find("name")->second;
+    assert(m_commandToHandle.find(name) != m_commandToHandle.end());
+    auto const& handlesIt = m_handles.find(m_commandToHandle.find(name)->second);
+    assert(handlesIt != m_handles.end());
+    auto const& commandsIt = handlesIt->second.commands.find(name);
+    assert(commandsIt != handlesIt->second.commands.end());
+    commandsIt->second.platform = platform;
+  }
+}
+
+void VulkanHppGenerator::readExtensionRequireEnum(tinyxml2::XMLElement const* element, std::string const& tag)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(),
+  {
+    { "name",{} }
+  },
+  {
+    { "alias",{} },
+    { "bitpos",{} },
+    { "comment",{} },
+    { "dir",{ "-" } },
+    { "extends",{} },
+    { "extnumber",{} },
+    { "offset",{} },
+    { "value",{} }
+  });
+  checkElements(getChildElements(element), {});
+
+  // TODO process enums which don't extend existing enums
+  auto extendsIt = attributes.find("extends");
+  if (extendsIt != attributes.end())
+  {
+    bool bitmask = false;
+    std::string extends = extendsIt->second;
+    auto enumIt = m_enums.find(extends);
+    if (enumIt == m_enums.end())
+    {
+      enumIt = m_bitmaskBits.find(extends);
+      assert(enumIt != m_bitmaskBits.end());
+      bitmask = true;
+    }
+
+    std::string prefix = getEnumPrefix(enumIt->first, bitmask);
+    std::string postfix = getEnumPostfix(enumIt->first, m_tags, prefix);
+
+    auto nameIt = attributes.find("name");
+    assert(nameIt != attributes.end());
+
+    auto aliasIt = attributes.find("alias");
+    if (aliasIt != attributes.end())
+    {
+      checkAttributes(attributes, element->GetLineNum(), { { "alias",{} },{ "extends",{} },{ "name",{} } }, { { "comment",{} } });
+      enumIt->second.addAlias(nameIt->second, aliasIt->second, bitmask, prefix, postfix, tag);
+    }
+    else
+    {
+      assert((attributes.find("bitpos") != attributes.end()) + (attributes.find("offset") != attributes.end()) + (attributes.find("value") != attributes.end()) == 1);
+      enumIt->second.addEnumValue(nameIt->second, bitmask, prefix, postfix, tag);
+    }
+  }
+}
+
+void VulkanHppGenerator::readExtensionRequireType(tinyxml2::XMLElement const* element, std::string const& platform)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), { { "name",{} } }, {});
+  checkElements(getChildElements(element), {});
+
+  // add the protect-string to the appropriate type: enum, flag, handle, scalar, or struct
+  if (!platform.empty())
+  {
+    std::string name = attributes.find("name")->second;
+
+    assert(m_handles.find(name) == m_handles.end());
+    std::string protect = m_platforms.find(platform)->second;
+
+    auto bmit = m_bitmasks.find(name);
+    if (bmit != m_bitmasks.end())
+    {
+      bmit->second.platform = platform;
+      assert(m_bitmaskBits.find(bmit->second.requires) != m_bitmaskBits.end());
+    }
+    else
+    {
+      std::string strippedName = stripPrefix(name, "Vk");
+      std::map<std::string, StructureData>::iterator stit = m_structures.find(name);
+      if (stit != m_structures.end())
+      {
+        stit->second.protect = protect;
+      }
+      else
+      {
+        assert((m_defines.find(strippedName) != m_defines.end()) || (m_enums.find(name) != m_enums.end()));
+      }
+    }
+  }
+}
+
+void VulkanHppGenerator::readExtensions(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), { { "comment",{} } }, {});
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "extension" });
+
+  for (auto child : children)
+  {
+    readExtension(child);
+  }
+}
+
+void VulkanHppGenerator::readFeature(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), { { "api",{ "vulkan" } },{ "comment",{} },{ "name",{} },{ "number",{} } }, {});
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "require" });
+
+  for (auto child : children)
+  {
+    readFeatureRequire(child);
+  }
+}
+
+void VulkanHppGenerator::readFeatureRequire(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), {}, { { "comment",{} } });
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "command", "comment", "enum", "type" });
+
+  for (auto child : children)
+  {
+    std::string value = child->Value();
+    if (value == "enum")
+    {
+      readFeatureRequireEnum(child);
+    }
+  }
+}
+
+void VulkanHppGenerator::readFeatureRequireEnum(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(),
+  {
+    { "name",{} }
+  },
+  {
+    { "bitpos",{} },
+    { "comment",{} },
+    { "dir", { "-" } },
+    { "extends",{} },
+    { "extnumber", {} },
+    { "offset", {} },
+    { "value",{} }
+  });
+  checkElements(getChildElements(element), {});
+
+  auto extendsAttribute = attributes.find("extends");
+  if (extendsAttribute != attributes.end())
+  {
+    bool bitmask = false;
+    assert(strncmp(extendsAttribute->second.c_str(), "Vk", 2) == 0);
+    std::string extends = extendsAttribute->second;
+    auto enumIt = m_enums.find(extends);
+    if (enumIt == m_enums.end())
+    {
+      enumIt = m_bitmaskBits.find(extends);
+      assert(enumIt != m_bitmaskBits.end());
+      bitmask = true;
+    }
+
+    std::string prefix = getEnumPrefix(enumIt->first, bitmask);
+    std::string postfix = getEnumPostfix(enumIt->first, m_tags, prefix);
+    enumIt->second.addEnumValue(attributes.find("name")->second, bitmask, prefix, postfix, "");
+  }
+}
+
+void VulkanHppGenerator::readFuncpointer(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes)
+{
+  checkAttributes(attributes, element->GetLineNum(), { { "category",{ "funcpointer" } } }, { { "requires",{} } });
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "name", "type" });
+  assert(!children.empty());
+  checkEmptyElement(children[0]);
+
+  assert((strcmp(children[0]->Value(), "name") == 0) && children[0]->GetText());
+#if !defined(NDEBUG)
+  for (size_t i = 1; i < children.size(); i++)
+  {
+    checkEmptyElement(children[i]);
+  }
+#endif
+}
+
+void VulkanHppGenerator::readHandle(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes)
+{
+  checkAttributes(attributes, element->GetLineNum(), { { "category",{ "handle" } } }, { { "alias",{} },{ "name",{} },{ "parent",{} } });
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+
+  auto aliasIt = attributes.find("alias");
+  if (aliasIt != attributes.end())
+  {
+    checkAttributes(attributes, element->GetLineNum(), { { "alias",{} },{ "category",{ "handle" } },{ "name",{} } }, {});   // re-check on alias type!
+    checkElements(children, {});
+    checkAlias(m_handles, aliasIt->second, element->GetLineNum());
+
+    auto handlesIt = m_handles.find(aliasIt->second);
+    assert((handlesIt != m_handles.end()) && handlesIt->second.alias.empty());
+    handlesIt->second.alias = attributes.find("name")->second;
+  }
+  else
+  {
+    checkOrderedElements(children, { "type", "name" });
+    checkEmptyElement(children[0]);
+    checkEmptyElement(children[1]);
+
+#if !defined(NDEBUG)
+    std::string type = children[0]->GetText();
+    assert((type.find("VK_DEFINE_HANDLE") == 0) || (type.find("VK_DEFINE_NON_DISPATCHABLE_HANDLE") == 0));
+#endif
+
+    std::string name = children[1]->GetText();
+
+    assert(m_handles.find(name) == m_handles.end());
+    m_handles.insert(std::make_pair(name, HandleData()));
+  }
+}
+
+void VulkanHppGenerator::readPlatform(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), { { "comment",{} },{ "name",{} },{ "protect",{} } }, {});
+  checkElements(getChildElements(element), {});
+
+  std::string name, protect;
+  for (auto const& attribute : attributes)
+  {
+    if (attribute.first == "name")
+    {
+      name = attribute.second;
+    }
+    else if (attribute.first == "protect")
+    {
+      protect = attribute.second;
+    }
+    else
+    {
+      assert(attribute.first == "comment");
+    }
+  }
+  assert(!name.empty() && !protect.empty());
+  assert(m_platforms.find(name) == m_platforms.end());
+  m_platforms[name] = protect;
+}
+
+void VulkanHppGenerator::readPlatforms(tinyxml2::XMLElement const* element)
+{
+  checkAttributes(getAttributes(element), element->GetLineNum(), { { "comment",{} } }, {});
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "platform" });
+
+  // init m_platforms with "" -> ""
+  assert(m_platforms.empty());
+  m_platforms[""] = "";
+
+  for (auto child : children)
+  {
+    readPlatform(child);
+  }
+}
+
+void VulkanHppGenerator::readStruct(tinyxml2::XMLElement const* element, bool isUnion, std::map<std::string, std::string> const& attributes)
+{
+  checkAttributes(attributes, element->GetLineNum(),
+  {
+    { "category",{ isUnion ? "union" : "struct" } },
+    { "name",{} }
+  },
+  {
+    { "alias",{} },
+    { "comment",{} },
+    { "returnedonly",{ "true" } },
+    { "structextends",{} }
+  });
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "comment", "member" });
+
+  std::string name = attributes.find("name")->second;
+
+  auto aliasIt = attributes.find("alias");
+  if (aliasIt != attributes.end())
+  {
+    readStructAlias(element->GetLineNum(), name, aliasIt->second, attributes);
+  }
+  else
+  {
+    assert(m_structures.find(name) == m_structures.end());
+    std::map<std::string, StructureData>::iterator it = m_structures.insert(std::make_pair(name, StructureData())).first;
+    it->second.returnedOnly = (attributes.find("returnedonly") != attributes.end());
+    it->second.isUnion = isUnion;
+
+    readStructStructExtends(attributes, it->second.structExtends, m_extendedStructs);
+    it->second.members = readStructMembers(children);
+    it->second.subStruct = determineSubStruct(*it);
+  }
+}
+
+void VulkanHppGenerator::readStructAlias(int lineNum, std::string const& name, std::string const& alias, std::map<std::string, std::string> const& attributes)
+{
+  checkAttributes(attributes, lineNum, { { "alias",{} },{ "category",{ "struct" } },{ "name",{} } }, {});    // re-check on alias type!
+  checkAlias(m_structures, alias, lineNum);
+
+  auto structsIt = m_structures.find(alias);
+  assert((structsIt != m_structures.end()) && structsIt->second.alias.empty());
+  structsIt->second.alias = stripPrefix(name, "Vk");
+
+  assert(m_structureAliases.find(name) == m_structureAliases.end());
+  m_structureAliases[name] = alias;
+}
+
+VulkanHppGenerator::MemberData VulkanHppGenerator::readStructMember(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), {},
+  {
+    { "altlen",{} },
+    { "externsync",{ "true" } },
+    { "len",{} },
+    { "noautovalidity",{ "true" } },
+    { "optional",{ "false", "true" } },
+    { "values",{} }
+  });
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "comment", "enum", "name", "type" });
+  for (auto child : children)
+  {
+    checkEmptyElement(child);
+  }
+
+  MemberData memberData;
+  auto valuesAttribute = attributes.find("values");
+  if (valuesAttribute != attributes.end())
+  {
+    memberData.values = valuesAttribute->second;
+  }
+
+  tinyxml2::XMLNode const* child = element->FirstChild();
+  assert(child);
+  if (child->ToText())
+  {
+    std::string value = trim(child->Value());
+    assert((value == "const") || (value == "struct") || value == "const struct");
+    memberData.type.prefix = value;
+    child = child->NextSibling();
+    assert(child);
+  }
+
+  assert(child->ToElement());
+  tinyxml2::XMLElement const* typeElement = child->ToElement();
+  assert((strcmp(typeElement->Value(), "type") == 0) && typeElement->GetText());
+  memberData.type.type = typeElement->GetText();
+
+  child = typeElement->NextSibling();
+  assert(child);
+  if (child->ToText())
+  {
+    std::string value = trimEnd(child->Value());
+    assert((value == "*") || (value == "**") || (value == "* const*"));
+    memberData.type.postfix = value;
+    child = child->NextSibling();
+  }
+
+  assert(child->ToElement());
+  tinyxml2::XMLElement const* nameElement = child->ToElement();
+  assert((strcmp(nameElement->Value(), "name") == 0) && nameElement->GetText());
+  memberData.name = nameElement->GetText();
+
+  memberData.arraySize = readArraySize(nameElement, memberData.name);
+  return memberData;
+}
+
+std::vector<VulkanHppGenerator::MemberData> VulkanHppGenerator::readStructMembers(std::vector<tinyxml2::XMLElement const*> const& children)
+{
+  std::vector<MemberData> members;
+  for (auto child : children)
+  {
+    assert(child->Value());
+    std::string value = child->Value();
+    if (value == "member")
+    {
+      members.push_back(readStructMember(child));
+    }
+#if !defined(NDEBUG)
+    else
+    {
+      assert(value == "comment");
+      checkEmptyElement(child);
+    }
+#endif
+  }
+  return members;
+}
+
+void VulkanHppGenerator::readTags(tinyxml2::XMLElement const* element)
+{
+  checkAttributes(getAttributes(element), element->GetLineNum(), { { "comment",{} } }, {});
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "tag" });
+
+  for (auto child : children)
+  {
+    readTag(child);
+  }
+}
+
+void VulkanHppGenerator::readTag(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+  checkAttributes(attributes, element->GetLineNum(), { { "author",{} },{ "contact",{} },{ "name",{} } }, {});
+  checkElements(getChildElements(element), {});
+
+  for (auto const& attribute : attributes)
+  {
+    std::string name = attribute.first;
+    if (name == "name")
+    {
+      std::string value = attribute.second;
+      assert(m_tags.find(value) == m_tags.end());
+      m_tags.insert(value);
+    }
+    else
+    {
+      assert((name == "author") || (name == "contact"));
+    }
+  }
+}
+
+void VulkanHppGenerator::readType(tinyxml2::XMLElement const* element)
+{
+  std::map<std::string, std::string> attributes = getAttributes(element);
+
+  auto categoryIt = attributes.find("category");
+  if (categoryIt != attributes.end())
+  {
+    if (categoryIt->second == "basetype")
+    {
+      readBaseType(element, attributes);
+    }
+    else if (categoryIt->second == "bitmask")
+    {
+      readBitmask(element, attributes);
+    }
+    else if (categoryIt->second == "define")
+    {
+      readDefine(element, attributes);
+    }
+    else if (categoryIt->second == "funcpointer")
+    {
+      readFuncpointer(element, attributes);
+    }
+    else if (categoryIt->second == "handle")
+    {
+      readHandle(element, attributes);
+    }
+    else if (categoryIt->second == "struct")
+    {
+      readStruct(element, false, attributes);
+    }
+    else if (categoryIt->second == "union")
+    {
+      readStruct(element, true, attributes);
+    }
+    else if ((categoryIt->second != "enum") && (categoryIt->second != "include"))
+    {
+      std::stringstream ss;
+      ss << element->GetLineNum();
+      std::string lineNumber = ss.str();
+
+      throw std::runtime_error("Spec error on line " + lineNumber + ": unknown category <" + categoryIt->second + ">");
+    }
+  }
+  else
+  {
+    assert(attributes.find("name") != attributes.end());
+  }
+}
+
+void VulkanHppGenerator::readTypes(tinyxml2::XMLElement const* element)
+{
+  checkAttributes(getAttributes(element), element->GetLineNum(), { { "comment",{} } }, {});
+  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
+  checkElements(children, { "comment", "type" });
+
+  for (auto child : children)
+  {
+    std::string value = child->Value();
+    if (value == "type")
+    {
+      readType(child);
+    }
+#if !defined(NDEBUG)
+    else
+    {
+      assert(value == "comment");
+      checkEmptyElement(child);
+    }
+#endif
+  }
+}
+
+void VulkanHppGenerator::registerDeleter(std::string const& name, std::pair<std::string, CommandData> const& commandData)
+{
+  if ((commandData.first.substr(2, 7) == "Destroy") || (commandData.first.substr(2, 4) == "Free"))
+  {
+    std::string key;
+    size_t valueIndex;
+    switch (commandData.second.params.size())
+    {
+    case 2:
+    case 3:
+      assert(commandData.second.params.back().type.type == "VkAllocationCallbacks");
+      key = (commandData.second.params.size() == 2) ? "" : commandData.second.params[0].type.type;
+      valueIndex = commandData.second.params.size() - 2;
+      break;
+    case 4:
+      key = commandData.second.params[0].type.type;
+      valueIndex = 3;
+      assert(m_handles.find(commandData.second.params[valueIndex].type.type) != m_handles.end());
+      m_handles.find(commandData.second.params[valueIndex].type.type)->second.deletePool = commandData.second.params[1].type.type;
+      break;
+    default:
+      assert(false);
+      valueIndex = 0;
+    }
+    auto keyHandleIt = m_handles.find(key);
+    assert((keyHandleIt != m_handles.end()) && (keyHandleIt->second.childrenHandles.find(commandData.second.params[valueIndex].type.type) == keyHandleIt->second.childrenHandles.end()));
+    keyHandleIt->second.childrenHandles.insert(commandData.second.params[valueIndex].type.type);
+
+    auto handleIt = m_handles.find(commandData.second.params[valueIndex].type.type);
+    assert(handleIt != m_handles.end());
+    handleIt->second.deleteCommand = name;
+  }
+}
+
+void VulkanHppGenerator::unlinkCommandFromHandle(std::string const& name)
+{
+  assert(m_commandToHandle.find(name) != m_commandToHandle.end());
+  auto handlesIt = m_handles.find(m_commandToHandle.find(name)->second);
+  assert(handlesIt != m_handles.end());
+  auto it = handlesIt->second.commands.find(name);
+  assert(it != handlesIt->second.commands.end());
+  handlesIt->second.commands.erase(it);
+}
+
+void VulkanHppGenerator::writeArgumentPlainType(std::ostream & os, ParamData const& paramData) const
+{
+  // this parameter is just a plain type
+  if (!paramData.type.postfix.empty())
+  {
+    assert(paramData.type.postfix.back() == '*');
+    // it's a pointer
+    std::string parameterName = startLowerCase(stripPrefix(paramData.name, "p"));
+    if (paramData.type.prefix.find("const") != std::string::npos)
+    {
+      // it's a const pointer
+      if (paramData.type.type == "char")
+      {
+        // it's a const pointer to char -> it's a string -> get the data via c_str()
+        os << parameterName << paramData.optional ? (" ? " + parameterName + "->c_str() : nullptr") : ".c_str()";
+      }
+      else
+      {
+        // it's const pointer to something else -> just use the name
+        assert(!paramData.optional);
+        os << paramData.name;
+      }
+    }
+    else
+    {
+      // it's a non-const pointer, and char is the only type that occurs -> use the address of the parameter
+      assert(paramData.type.type.find("char") == std::string::npos);
+      os << "&" << parameterName;
+    }
+  }
+  else
+  {
+    // it's a plain parameter -> just use its name
+    os << paramData.name;
+  }
+}
+
+void VulkanHppGenerator::writeArguments(std::ostream & os, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool firstCall, bool singular, size_t from, size_t to) const
+{
+  assert(from <= to);
+
+  bool encounteredArgument = false;
+  for (size_t i = from; i < to; i++)
+  {
+    if (encounteredArgument)
+    {
+      os << ", ";
+    }
+
+    auto it = vectorParamIndices.find(i);
+    if (it != vectorParamIndices.end())
+    {
+      writeArgumentVector(os, it->first, commandData.params[it->first], returnParamIndex, templateParamIndex, twoStep, firstCall, singular);
+    }
+    else
+    {
+      it = find_if(vectorParamIndices.begin(), vectorParamIndices.end(), [i](std::pair<size_t, size_t> const& vpi) { return vpi.second == i; });
+      if (it != vectorParamIndices.end())
+      {
+        writeArgumentCount(os, it->first, commandData.params[it->first].name, commandData.params[it->second].name, returnParamIndex, templateParamIndex, twoStep, singular);
+      }
+      else if (beginsWith(commandData.params[i].type.type, "Vk"))
+      {
+        writeArgumentVulkanType(os, commandData.params[i]);
+      }
+      else
+      {
+        writeArgumentPlainType(os, commandData.params[i]);
+      }
+    }
+    encounteredArgument = true;
+  }
+}
+
+void VulkanHppGenerator::writeArgumentVector(std::ostream & os, size_t paramIndex, ParamData const& paramData, size_t returnParamIndex, size_t templateParamIndex, bool twoStep, bool firstCall, bool singular) const
+{
+  // this parameter is a vector parameter
+  assert(paramData.type.postfix.back() == '*');
+  if ((returnParamIndex == paramIndex) && twoStep && firstCall)
+  {
+    // this parameter is the return parameter, and it's the first call of a two-step algorithm -> just just nullptr
+    os << "nullptr";
+  }
+  else
+  {
+    std::string parameterName = startLowerCase(stripPrefix(paramData.name, "p"));
+    if (beginsWith(paramData.type.type, "Vk") || (paramIndex == templateParamIndex))
+    {
+      // CHECK for !commandData.params[it->first].optional
+
+      // this parameter is a vulkan type or a templated type -> need to reinterpret cast
+      os << writeReinterpretCast(paramData.type.prefix.find("const") == 0, paramData.type.type, paramData.type.postfix.rfind("* const") != std::string::npos);
+      os << "( " << (singular ? ("&" + stripPluralS(parameterName)) : (parameterName + ".data()")) << " )";
+    }
+    else if (paramData.type.type == "char")
+    {
+      // the parameter is a vector to char -> it might be optional
+      // besides that, the parameter now is a std::string -> get the pointer via c_str()
+      os << parameterName << (paramData.optional ? (" ? " + parameterName + "->c_str() : nullptr") : ".c_str()");
+    }
+    else
+    {
+      // this parameter is just a vetor -> get the pointer to its data
+      os << parameterName << ".data()";
+    }
+  }
+}
+
+void VulkanHppGenerator::writeArgumentVulkanType(std::ostream & os, ParamData const& paramData) const
+{
+  // this parameter is a vulkan type
+  if (!paramData.type.postfix.empty())
+  {
+    assert(paramData.type.postfix.back() == '*');
+    // it's a pointer -> needs a reinterpret cast to the vulkan type
+    std::string parameterName = startLowerCase(stripPrefix(paramData.name, "p"));
+    os << writeReinterpretCast(paramData.type.prefix.find("const") != std::string::npos, paramData.type.type, false);
+    os << "( ";
+    if (paramData.optional)
+    {
+      // for an optional parameter, we need also a static_cast from optional type to const-pointer to pure type
+      os << "static_cast<const " << stripPrefix(paramData.type.type, "Vk") << "*>( " << parameterName << " )";
+    }
+    else
+    {
+      // other parameters can just use the pointer
+      os << "&" << parameterName;
+    }
+    os << " )";
+  }
+  else
+  {
+    // a non-pointer parameter needs a static_cast from vk::-type to vulkan type
+    os << "static_cast<" << paramData.type.type << ">( " << paramData.name << " )";
+  }
+}
+
+void VulkanHppGenerator::writeBaseTypes(std::ostream & os) const
+{
+  assert(!m_baseTypes.empty());
+  for (auto const& baseType : m_baseTypes)
+  {
+    if (baseType.first != "VkFlags")    // filter out VkFlags
+    {
+      os << "  using " << stripPrefix(baseType.first, "Vk") << " = " << baseType.second << ";" << std::endl;
+    }
+  }
+}
+
+void VulkanHppGenerator::writeBitmasks(std::ostream & os) const
+{
+  for (auto const& bitmask : m_bitmasks)
+  {
+    std::string protect = bitmask.second.platform.empty() ? "" : m_platforms.find(bitmask.second.platform)->second;
+    if (!protect.empty())
+    {
+      os << std::endl
+        << "#ifdef " << protect;
+    }
+
+    auto bitmaskBits = m_bitmaskBits.find(bitmask.second.requires);
+    assert(bitmaskBits != m_bitmaskBits.end());
+    writeEnum(os, *bitmaskBits);
+    std::string strippedEnumName = stripPrefix(bitmaskBits->first, "Vk");
+    writeEnumToString(os, strippedEnumName, bitmaskBits->second.values);
+    std::string strippedBitmaskName = stripPrefix(bitmask.first, "Vk");
+    writeBitmask(os, strippedBitmaskName, bitmask.second.alias, strippedEnumName, bitmaskBits->second.values);
+    writeBitmaskToStringFunction(os, strippedBitmaskName, strippedEnumName, bitmaskBits->second.values);
+
+    leaveProtect(os, protect);
+  }
+}
+
+void VulkanHppGenerator::writeCommand(std::ostream & os, std::string const& indentation, std::string const& name, std::pair<std::string, CommandData> const& commandData, bool definition) const
+{
+  os << std::endl;
+  assert(m_platforms.find(commandData.second.platform) != m_platforms.end());
+  std::string const& protect = m_platforms.find(commandData.second.platform)->second;
+  enterProtect(os, protect);
+
+  bool twoStep = isTwoStepAlgorithm(commandData.second.params);
+  std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices(commandData.second.params);
+
+  size_t returnParamIndex = determineReturnParamIndex(commandData.second, vectorParamIndices, twoStep);
+  bool isStructureChain = (returnParamIndex != INVALID_INDEX) && determineStructureChaining(commandData.second.params[returnParamIndex].type.type, m_extendedStructs, m_structureAliases);
+  std::string enhancedReturnType = determineEnhancedReturnType(commandData.second, returnParamIndex, vectorParamIndices, twoStep, false);   // get the enhanced return type without structureChain
+
+  size_t templateParamIndex = determineTemplateParamIndex(commandData.second.params, vectorParamIndices);
+
+  // first create the standard version of the function
+  std::ostringstream standard;
+  writeFunction(standard, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, enhancedReturnType, definition, false, false, false, false, false);
+
+  // then the enhanced version, composed by up to eight parts
+  std::ostringstream enhanced;
+  writeFunction(enhanced, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, enhancedReturnType, definition, true, false, false, false, false);
+
+  if (enhancedReturnType.find("Allocator") != std::string::npos)
+  {
+    writeFunction(enhanced, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, enhancedReturnType, definition, true, false, false, false, true);
+  }
+
+  if (isStructureChain)
+  {
+    std::string enhancedReturnTypeWithStructureChain = determineEnhancedReturnType(commandData.second, returnParamIndex, vectorParamIndices, twoStep, true);
+    writeFunction(enhanced, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, enhancedReturnTypeWithStructureChain, definition, true, false, false, true, false);
+
+    if (enhancedReturnTypeWithStructureChain.find("Allocator") != std::string::npos)
+    {
+      writeFunction(enhanced, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, enhancedReturnTypeWithStructureChain, definition, true, false, false, true, true);
+    }
+  }
+
+  // then a singular version, if a sized vector would be returned
+  std::map<size_t, size_t>::const_iterator returnVector = vectorParamIndices.find(returnParamIndex);
+  bool singular = (returnVector != vectorParamIndices.end()) &&
+    (returnVector->second != INVALID_INDEX) &&
+    (commandData.second.params[returnVector->first].type.type != "void") &&
+    (commandData.second.params[returnVector->second].type.postfix.empty() || (commandData.second.params[returnVector->second].type.postfix.back() != '*'));
+  if (singular)
+  {
+    writeFunction(enhanced, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, enhancedReturnType, definition, true, true, false, false, false);
+  }
+
+  // special handling for createDevice and createInstance !
+  bool specialWriteUnique = (commandData.first == "vkCreateDevice") || (commandData.first == "vkCreateInstance");
+
+  // and then the same for the Unique* versions (a deleteCommand is available for the commandData's class, and the function starts with 'allocate' or 'create')
+  assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
+  auto handleIt = m_handles.find(m_commandToHandle.find(commandData.first)->second);
+  assert(handleIt != m_handles.end());
+  if ((!handleIt->second.deleteCommand.empty() || specialWriteUnique) && ((commandData.first.substr(2, 8) == "Allocate") || (commandData.first.substr(2, 6) == "Create")))
+  {
+    enhanced << "#ifndef VULKAN_HPP_NO_SMART_HANDLE" << std::endl;
+    writeFunction(enhanced, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, enhancedReturnType, definition, true, false, true, false, false);
+
+    if (enhancedReturnType.find("Allocator") != std::string::npos)
+    {
+      writeFunction(enhanced, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, enhancedReturnType, definition, true, false, true, false, true);
+    }
+
+    if (singular)
+    {
+      writeFunction(enhanced, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, enhancedReturnType, definition, true, true, true, false, false);
+    }
+    enhanced << "#endif /*VULKAN_HPP_NO_SMART_HANDLE*/" << std::endl;
+  }
+
+  // and write one or both of them
+  std::string standardString = standard.str();
+  std::string enhancedString = enhanced.str();
+  if (standardString == enhancedString)
+  {
+    // standard and enhanced string are equal -> just use one of them and we're done
+    os << standardString;
+  }
+  else
+  {
+    // standard and enhanced string differ -> use both, wrapping the enhanced by !VULKAN_HPP_DISABLE_ENHANCED_MODE
+    // determine the argument list of that standard, and compare it with that of the enhanced
+    // if they are equal -> need to have just one; if they differ -> need to have both
+    size_t standardStart = standardString.find('(');
+    size_t standardCount = standardString.find(')', standardStart) - standardStart;
+    size_t enhancedStart = enhancedString.find('(');
+    bool unchangedInterface = (standardString.substr(standardStart, standardCount) == enhancedString.substr(enhancedStart, standardCount));
+    if (unchangedInterface)
+    {
+      os << "#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE" << std::endl;
+    }
+    os << standardString
+      << (unchangedInterface ? "#else" : "#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE") << std::endl
+      << enhancedString
+      << "#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/" << std::endl;
+  }
+
+  leaveProtect(os, protect);
+}
+
+void VulkanHppGenerator::writeDispatchLoaderDynamic(std::ostream &os)
+{
+  os << std::endl
+    << "  class DispatchLoaderDynamic" << std::endl
+    << "  {" << std::endl
+    << "  public:" << std::endl;
+
+  for (auto const& handle : m_handles)
+  {
+    for (auto const& command : handle.second.commands)
+    {
+      std::string const& protect = m_platforms.find(command.second.platform)->second;
+      enterProtect(os, protect);
+      os << "    PFN_" << command.first << " " << command.first << " = 0;" << std::endl;
+      leaveProtect(os, protect);
+    }
+  }
+
+  // write initialization function to fetch function pointers
+  os << "  public:" << std::endl
+    << "    DispatchLoaderDynamic(Instance instance = Instance(), Device device = Device())" << std::endl
+    << "    {" << std::endl
+    << "      if (instance)" << std::endl
+    << "      {" << std::endl
+    << "        init(instance, device);" << std::endl
+    << "      }" << std::endl
+    << "    }" << std::endl << std::endl
+    << "    void init(Instance instance, Device device = Device())" << std::endl
+    << "    {" << std::endl;
+
+  for (auto const& handle : m_handles)
+  {
+    for (auto const& command : handle.second.commands)
+    {
+      std::string const& protect = m_platforms.find(command.second.platform)->second;
+      enterProtect(os, protect);
+      if (!command.second.params.empty()
+        && m_handles.find(command.second.params[0].type.type) != m_handles.end()
+        && command.second.params[0].type.type != "VkInstance"
+        && command.second.params[0].type.type != "VkPhysicalDevice")
+      {
+        os << "      " << command.first << " = PFN_" << command.first
+          << "(device ? device.getProcAddr( \"" << command.first << "\") : instance.getProcAddr( \"" << command.first << "\"));" << std::endl;
+      }
+      else
+      {
+        os << "      " << command.first << " = PFN_" << command.first << "(instance.getProcAddr( \"" << command.first << "\"));" << std::endl;
+      }
+      leaveProtect(os, protect);
+    }
+  }
+  os << "    }" << std::endl;
+  os << "  };\n";
+}
+
+void VulkanHppGenerator::writeDispatchLoaderStatic(std::ostream &os)
+{
+  static const std::string commandTemplate = R"(${enterProtect}
+    ${returnType} vk${commandName}( ${parameterList} ) const
+    {
+      return ::vk${commandName}( ${parameters} );
+    }
+${leaveProtect})";
+
+  std::ostringstream commands;
+  for (auto const& handle : m_handles)
+  {
+    for (auto const& command : handle.second.commands)
+    {
+      std::string parameterList, parameters;
+      bool firstParam = true;
+      for (auto param : command.second.params)
+      {
+        if (!firstParam)
+        {
+          parameterList += ", ";
+          parameters += ", ";
+        }
+        parameterList += param.type.prefix + (param.type.prefix.empty() ? "" : " ") + param.type.type + param.type.postfix + " " + param.name;
+        if (!param.arraySize.empty())
+        {
+          parameterList += "[" + param.arraySize + "]";
+        }
+        parameters += param.name;
+        firstParam = false;
+      }
+
+      std::string const& protect = m_platforms.find(command.second.platform)->second;
+      commands << replaceWithMap(commandTemplate,
+      {
+        { "enterProtect", protect.empty() ? "" : ("\n#ifdef " + protect) },
+        { "returnType", command.second.returnType },
+        { "commandName", stripPrefix(command.first, "vk") },
+        { "parameterList", parameterList },
+        { "parameters", parameters },
+        { "leaveProtect", protect.empty() ? "" : ("#endif /*" + protect + "*/\n") }
+      });
+    }
+  }
+
+  static const std::string dispatchTemplate = R"(
+  class DispatchLoaderStatic
+  {
+  public:${commands}  };
+)";
+
+  os << replaceWithMap(dispatchTemplate, { { "commands", commands.str() } });
+}
+
+void VulkanHppGenerator::writeEnum(std::ostream & os, std::pair<std::string,EnumData> const& enumData) const
+{
+  std::string values;
+  for (auto const& value : enumData.second.values)
+  {
+    if (!values.empty())
+    {
+      values += ",";
+    }
+    values += "\n    " + value.second + " = " + value.first;
+  }
+  for (auto const& value : enumData.second.aliases)
+  {
+    if (!values.empty())
+    {
+      values += ",";
+    }
+    values += "\n    " + value.second + " = " + value.first;
+  }
+  if (!values.empty())
+  {
+    values += "\n  ";
+  }
+
+  static const std::string enumTemplate = R"(
+  enum class ${name}
+  {${values}};
+)";
+
+  os << replaceWithMap(enumTemplate,
+  {
+    { "name", stripPrefix(enumData.first, "Vk") },
+    { "values", values },
+  });
+}
+
+void VulkanHppGenerator::writeEnums(std::ostream & os) const
+{
+  for (auto const& e : m_enums)
+  {
+    writeEnum(os, e);
+    writeEnumToString(os, stripPrefix(e.first, "Vk"), e.second.values);
+  }
+}
+
+void VulkanHppGenerator::writeForwardDeclarations(std::ostream & os, std::set<std::string> const& forwardDeclarations) const
+{
+  os << std::endl;
+  for (auto const& fd : forwardDeclarations)
+  {
+    auto structureIt = m_structures.find(fd);
+    assert(structureIt != m_structures.end());
+    enterProtect(os, structureIt->second.protect);
+    os << "  " << (structureIt->second.isUnion ? "union" : "struct") << " " << stripPrefix(structureIt->first, "Vk") << ";" << std::endl;
+    if (!structureIt->second.alias.empty())
+    {
+      os << "  using " << stripPrefix(structureIt->second.alias, "Vk") << " = " << stripPrefix(structureIt->first, "Vk") << ";" << std::endl;
+    }
+    leaveProtect(os, structureIt->second.protect);
+  }
+}
+
+void VulkanHppGenerator::writeFunction(std::ostream & os, std::string const& indentation, std::string const& name, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool definition, bool enhanced, bool singular, bool unique, bool isStructureChain, bool withAllocator) const
+{
+  writeFunctionHeaderTemplate(os, indentation, returnParamIndex, templateParamIndex, enhancedReturnType, enhanced, singular, unique, !definition, isStructureChain);
+
+  os << indentation << (definition ? "VULKAN_HPP_INLINE " : "");
+  writeFunctionHeaderReturnType(os, commandData.second, returnParamIndex, vectorParamIndices, enhancedReturnType, enhanced, singular, unique, isStructureChain);
+  assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
+  std::string const& handle = m_commandToHandle.find(commandData.first)->second;
+  if (definition && !handle.empty())
+  {
+    os << stripPrefix(handle, "Vk") << "::";
+  }
+
+  // write the function header name
+  os << (singular ? stripPluralS(name) : name);
+  if (unique)
+  {
+    os << "Unique";
+  }
+
+  writeFunctionHeaderArguments(os, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, enhanced, singular, !definition, withAllocator);
+  os << (definition ? "" : ";") << std::endl;
+
+  if (definition)
+  {
+    // write the function body
+    os << indentation << "{" << std::endl;
+    if (enhanced)
+    {
+      writeFunctionBodyEnhanced(os, indentation, name, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, enhancedReturnType, singular, unique, isStructureChain, withAllocator);
+    }
+    else
+    {
+      writeFunctionBodyStandard(os, indentation, commandData);
+    }
+    os << indentation << "}" << std::endl;
+  }
+}
+
+void VulkanHppGenerator::writeFunctionBodyEnhanced(std::ostream & os, std::string const& indentation, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool singular, bool unique, bool isStructureChain, bool withAllocator) const
+{
+  if (unique && !singular && (vectorParamIndices.find(returnParamIndex) != vectorParamIndices.end()))    // returns a vector of UniqueStuff
+  {
+    writeFunctionBodyEnhancedVectorOfUniqueHandles(os, indentation, commandName, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, singular, withAllocator);
+  }
+  else
+  {
+    if (1 < vectorParamIndices.size())
+    {
+      writeFunctionBodyEnhancedMultiVectorSizeCheck(os, indentation, commandName, commandData, returnParamIndex, vectorParamIndices);
+    }
+
+    std::string returnName;
+    if (returnParamIndex != INVALID_INDEX)
+    {
+      returnName = writeFunctionBodyEnhancedLocalReturnVariable(os, indentation, commandData.second, returnParamIndex, vectorParamIndices, twoStep, enhancedReturnType, singular, isStructureChain, withAllocator);
+    }
+
+    if (twoStep)
+    {
+      writeFunctionBodyEnhancedTwoStep(os, indentation, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, singular, returnName);
+    }
+    else
+    {
+      writeFunctionBodyEnhancedSingleStep(os, indentation, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, singular);
+    }
+
+    if ((commandData.second.returnType == "VkResult") || !commandData.second.successCodes.empty())
+    {
+      writeFunctionBodyEnhancedReturnResultValue(os, indentation, returnName, commandName, commandData, returnParamIndex, twoStep, singular, unique);
+    }
+    else if ((returnParamIndex != INVALID_INDEX) && (stripPrefix(commandData.second.returnType, "Vk") != enhancedReturnType))
+    {
+      // for the other returning cases, when the return type is somhow enhanced, just return the local returnVariable
+      os << indentation << "  return " << returnName << ";" << std::endl;
+    }
+  }
+}
+
+std::string VulkanHppGenerator::writeFunctionBodyEnhancedLocalReturnVariable(std::ostream & os, std::string const& indentation, CommandData const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool singular, bool isStructureChain, bool withAllocator) const
+{
+  std::string pureReturnType = stripPrefix(commandData.params[returnParamIndex].type.type, "Vk");
+  std::string returnName = startLowerCase(stripPrefix(commandData.params[returnParamIndex].name, "p"));
+
+  // there is a returned parameter -> we need a local variable to hold that value
+  if (stripPrefix(commandData.returnType, "Vk") != enhancedReturnType)
+  {
+    // the returned parameter is somehow enhanced by us
+    os << indentation << "  ";
+    if (singular)
+    {
+      returnName = writeFunctionBodyEnhancedLocalReturnVariableSingular(os, indentation, pureReturnType, returnName, isStructureChain);
+    }
+    else
+    {
+      // in non-singular case, use the enhanced type for the return variable (like vector<...>)
+      if (isStructureChain && vectorParamIndices.empty())
+      {
+        // For StructureChains use the template parameters
+        std::string const returnVariableTemplate =
+R"(StructureChain<X, Y, Z...> structureChain;
+${i}  ${enhancedReturnType}& ${returnName} = structureChain.template get<${enhancedReturnType}>())";
+
+        os << replaceWithMap(returnVariableTemplate, { { "i", indentation }, { "enhancedReturnType", enhancedReturnType }, { "returnName", returnName } });
+        returnName = "structureChain";
+      }
+      else
+      {
+        os << enhancedReturnType << " " << returnName;
+      }
+
+      std::map<size_t, size_t>::const_iterator vpiIt = vectorParamIndices.find(returnParamIndex);
+      if (vpiIt != vectorParamIndices.end() && !twoStep)
+      {
+        writeFunctionBodyEnhancedLocalReturnVariableVectorSize(os, commandData.params, *vpiIt, returnParamIndex, vectorParamIndices, withAllocator);
+      }
+      else if (withAllocator)
+      {
+        os << "( vectorAllocator )";
+      }
+    }
+    os << ";" << std::endl;
+  }
+  else
+  {
+    // the return parameter is not enhanced -> the type is supposed to be a Result and there are more than one success codes!
+    assert((commandData.returnType == "VkResult") && (1 < commandData.successCodes.size()));
+    os << indentation << "  " << pureReturnType << " " << returnName << ";" << std::endl;
+  }
+
+  return returnName;
+}
+
+void VulkanHppGenerator::writeFunctionBodyEnhancedLocalReturnVariableVectorSize(std::ostream & os, std::vector<ParamData> const& params, std::pair<size_t, size_t> const& vectorParamIndex, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool withAllocator) const
+{
+  // if the return parameter is a vector parameter, and not part of a two-step algorithm, initialize its size
+  std::string size;
+  if (vectorParamIndex.second == INVALID_INDEX)
+  {
+    assert(!params[returnParamIndex].len.empty());
+    // the size of the vector is not given by an other parameter, but by some member of a parameter, described as 'parameter::member'
+    // -> replace the '::' by '.' and filter out the leading 'p' to access that value
+    size = startLowerCase(stripPrefix(params[returnParamIndex].len, "p"));
+    size_t pos = size.find("::");
+    assert(pos != std::string::npos);
+    size.replace(pos, 2, ".");
+  }
+  else
+  {
+    // the size of the vector is given by an other parameter
+    // first check, if that size has become the size of some other vector parameter
+    // -> look for it and get it's actual size
+    for (auto const& vpi : vectorParamIndices)
+    {
+      if ((vpi.first != vectorParamIndex.first) || (vpi.second != vectorParamIndex.second))
+      {
+        size = startLowerCase(stripPrefix(params[vpi.first].name, "p")) + ".size()";
+        break;
+      }
+    }
+    if (size.empty())
+    {
+      // otherwise, just use that parameter
+      size = params[vectorParamIndex.second].name;
+    }
+  }
+  assert(!size.empty());
+  os << "( " << size << (withAllocator ? ", vectorAllocator" : "") << " )";
+}
+
+void VulkanHppGenerator::writeFunctionBodyEnhancedMultiVectorSizeCheck(std::ostream & os, std::string const& indentation, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices) const
+{
+  std::string const sizeCheckTemplate =
+    R"#(#ifdef VULKAN_HPP_NO_EXCEPTIONS
+${i}  VULKAN_HPP_ASSERT( ${firstVectorName}.size() == ${secondVectorName}.size() );
 #else
-# define VULKAN_HPP_CONSTEXPR constexpr
+${i}  if ( ${firstVectorName}.size() != ${secondVectorName}.size() )
+${i}  {
+${i}    throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::${className}::${commandName}: ${firstVectorName}.size() != ${secondVectorName}.size()" );
+${i}  }
+#endif  /*VULKAN_HPP_NO_EXCEPTIONS*/
+)#";
+
+  assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
+  std::string const& handle = m_commandToHandle.find(commandData.first)->second;
+
+  // add some error checks if multiple vectors need to have the same size
+  for (std::map<size_t, size_t>::const_iterator it0 = vectorParamIndices.begin(); it0 != vectorParamIndices.end(); ++it0)
+  {
+    if (it0->first != returnParamIndex)
+    {
+      for (std::map<size_t, size_t>::const_iterator it1 = std::next(it0); it1 != vectorParamIndices.end(); ++it1)
+      {
+        if ((it1->first != returnParamIndex) && (it0->second == it1->second))
+        {
+          os << replaceWithMap(sizeCheckTemplate, std::map<std::string, std::string>({
+            { "firstVectorName", startLowerCase(stripPrefix(commandData.second.params[it0->first].name, "p")) },
+            { "secondVectorName", startLowerCase(stripPrefix(commandData.second.params[it1->first].name, "p")) },
+            { "className", handle },
+            { "commandName", commandName },
+            { "i", indentation }
+          }));
+        }
+      }
+    }
+  }
+}
+
+void VulkanHppGenerator::writeFunctionBodyEnhancedReturnResultValue(std::ostream & os, std::string const& indentation, std::string const& returnName, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, bool twoStep, bool singular, bool unique) const
+{
+  std::string type = (returnParamIndex != INVALID_INDEX) ? commandData.second.params[returnParamIndex].type.type : "";
+  std::string returnVectorName = (returnParamIndex != INVALID_INDEX) ? stripPostfix(stripPrefix(commandData.second.params[returnParamIndex].name, "p"), "s") : "";
+
+  assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
+  std::string const& handle = m_commandToHandle.find(commandData.first)->second;
+
+  if (unique)
+  {
+    // the unique version needs a Deleter object for destruction of the newly created stuff
+    // get the DeleterData corresponding to the returned type
+    // special handling for "createDevice", as Device is created from PhysicalDevice, but destroyed on its own
+    bool noParent = handle.empty() || (commandData.first == "vkCreateDevice");
+    os << std::endl
+      << indentation << ((commandData.first == "vkAllocateMemory") ? "  ObjectFree<" : "  ObjectDestroy<") << (noParent ? "NoParent" : stripPrefix(handle, "Vk")) << ",Dispatch> deleter( " << (noParent ? "" : "*this, ") << "allocator, d );" << std::endl
+      << indentation << "  return createResultValue<" << stripPrefix(type, "Vk") << ",Dispatch>( result, ";
+  }
+  else
+  {
+    os << indentation << "  return createResultValue( result, ";
+  }
+
+  // if the return type is "Result" or there is at least one success code, create the Result/Value construct to return
+  if (returnParamIndex != INVALID_INDEX)
+  {
+    // if there's a return parameter, list it in the Result/Value constructor
+    os << returnName << ", ";
+  }
+
+  // now the function name (with full namespace) as a string
+  os << "VULKAN_HPP_NAMESPACE_STRING\"::" << (handle.empty() ? "" : stripPrefix(handle, "Vk") + "::") << (singular ? stripPluralS(commandName) : commandName) << (unique ? "Unique" : "") << "\"";
+
+  if (!twoStep && (1 < commandData.second.successCodes.size()))
+  {
+    // and for the single-step algorithms with more than one success code list them all
+    os << ", { Result::" << commandData.second.successCodes[0];
+    for (size_t i = 1; i < commandData.second.successCodes.size(); i++)
+    {
+      os << ", Result::" << commandData.second.successCodes[i];
+    }
+    os << " }";
+  }
+
+  if (unique)
+  {
+    os << ", deleter";
+  }
+
+  os << " );" << std::endl;
+}
+
+void VulkanHppGenerator::writeFunctionBodyEnhancedSingleStep(std::ostream & os, std::string const& indentation, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular) const
+{
+  std::string const resultCallTemplate = "${i}  Result result = static_cast<Result>( ${call} );\n";
+  std::string const returnCallTemplate = "${i}  return ${call};\n";
+  std::string const voidCallTemplate = "${i}  ${call};\n";
+  std::string const& selectedTemplate = (commandData.second.returnType == "VkResult") ? resultCallTemplate : (commandData.second.returnType == "void") ? voidCallTemplate : returnCallTemplate;
+  os << replaceWithMap(selectedTemplate,
+  {
+    { "call", generateCall(commandData, returnParamIndex, templateParamIndex, vectorParamIndices, false, true, singular) },
+    { "i", indentation }
+  });
+}
+
+void VulkanHppGenerator::writeFunctionBodyEnhancedTwoStep(std::ostream & os, std::string const& indentation, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular, std::string const& returnName) const
+{
+  assert(!singular);
+  assert((commandData.second.returnType == "VkResult") || (commandData.second.returnType == "void"));
+  assert(returnParamIndex != INVALID_INDEX);
+
+  // local count variable to hold the size of the vector to fill
+  std::map<size_t, size_t>::const_iterator returnit = vectorParamIndices.find(returnParamIndex);
+  assert(returnit != vectorParamIndices.end() && (returnit->second != INVALID_INDEX));
+
+  // take the pure type of the size parameter; strip the leading 'p' from its name for its local name
+  std::string sizeName = startLowerCase(stripPrefix(commandData.second.params[returnit->second].name, "p"));
+  os << indentation << "  " << stripPrefix(commandData.second.params[returnit->second].type.type, "Vk") << " " << sizeName << ";" << std::endl;
+
+  std::string const multiSuccessTemplate =
+    R"(${i}  Result result;
+${i}  do
+${i}  {
+${i}    result = static_cast<Result>( ${call1} );
+${i}    if ( ( result == Result::eSuccess ) && ${sizeName} )
+${i}    {
+${i}      ${returnName}.resize( ${sizeName} );
+${i}      result = static_cast<Result>( ${call2} );
+${i}    }
+${i}  } while ( result == Result::eIncomplete );
+${i}  if ( result == Result::eSuccess )
+${i}  {
+${i}    VULKAN_HPP_ASSERT( ${sizeName} <= ${returnName}.size() );
+${i}    ${returnName}.resize( ${sizeName} );
+${i}  }
+)";
+  std::string const singleSuccessTemplate =
+    R"(${i}  Result result = static_cast<Result>( ${call1} );
+${i}  if ( ( result == Result::eSuccess ) && ${sizeName} )
+${i}  {
+${i}    ${returnName}.resize( ${sizeName} );
+${i}    result = static_cast<Result>( ${call2} );
+${i}  }
+)";
+  std::string const voidMultiCallTemplate =
+    R"(${i}  ${call1};
+${i}  ${returnName}.resize( ${sizeName} );
+${i}  ${call2};
+)";
+  std::string const& selectedTemplate = (commandData.second.returnType == "VkResult") ? ((1 < commandData.second.successCodes.size()) ? multiSuccessTemplate : singleSuccessTemplate) : voidMultiCallTemplate;
+  os << replaceWithMap(selectedTemplate,
+  {
+    { "sizeName", sizeName },
+    { "returnName", returnName },
+    { "call1", generateCall(commandData, returnParamIndex, templateParamIndex, vectorParamIndices, true, true, false) },
+    { "call2", generateCall(commandData, returnParamIndex, templateParamIndex, vectorParamIndices, true, false, false) },
+    { "i", indentation }
+  });
+}
+
+void VulkanHppGenerator::writeFunctionBodyEnhancedVectorOfUniqueHandles(std::ostream & os, std::string const& indentation, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool singular, bool withAllocator) const
+{
+  std::string const stringTemplate =
+    R"(${i}  static_assert( sizeof( ${type} ) <= sizeof( UniqueHandle<${type}, Dispatch> ), "${type} is greater than UniqueHandle<${type}, Dispatch>!" );
+${i}  std::vector<UniqueHandle<${type}, Dispatch>, Allocator> ${typeVariable}s${allocator};
+${i}  ${typeVariable}s.reserve( ${vectorSize} );
+${i}  ${type}* buffer = reinterpret_cast<${type}*>( reinterpret_cast<char*>( ${typeVariable}s.data() ) + ${vectorSize} * ( sizeof( UniqueHandle<${type}, Dispatch> ) - sizeof( ${type} ) ) );
+${i}  Result result = static_cast<Result>(d.vk${command}( m_device, ${arguments}, reinterpret_cast<Vk${type}*>( buffer ) ) );
+
+${i}  ${Deleter}<${DeleterTemplate},Dispatch> deleter( *this, ${deleterArg}, d );
+${i}  for ( size_t i=0 ; i<${vectorSize} ; i++ )
+${i}  {
+${i}    ${typeVariable}s.push_back( UniqueHandle<${type}, Dispatch>( buffer[i], deleter ) );
+${i}  }
+
+${i}  return createResultValue( result, ${typeVariable}s, VULKAN_HPP_NAMESPACE_STRING "::${class}::${commandName}Unique" );
+)";
+
+  std::string type = (returnParamIndex != INVALID_INDEX) ? commandData.second.params[returnParamIndex].type.type : "";
+  std::string typeVariable = startLowerCase(stripPrefix(type, "Vk"));
+  std::ostringstream arguments;
+  writeArguments(arguments, commandData.second, returnParamIndex, templateParamIndex, vectorParamIndices, twoStep, true, singular, 1, commandData.second.params.size() - 1);
+
+  assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
+  std::string const& handle = m_commandToHandle.find(commandData.first)->second;
+
+  auto handleIt = m_handles.find(type);
+  assert(handleIt != m_handles.end());
+
+  bool isCreateFunction = (commandData.first.substr(2, 6) == "Create");
+  os << replaceWithMap(stringTemplate, std::map<std::string, std::string>
+  {
+    { "i", indentation },
+    { "type", stripPrefix(type, "Vk") },
+    { "typeVariable", typeVariable },
+    { "allocator", withAllocator ? "( vectorAllocator )" : "" },
+    { "vectorSize", isCreateFunction ? "createInfos.size()" : "allocateInfo." + typeVariable + "Count" },
+    { "command", stripPrefix(commandData.first, "vk") },
+    { "arguments", arguments.str() },
+    { "Deleter", handleIt->second.deletePool.empty() ? "ObjectDestroy" : "PoolFree" },
+    { "DeleterTemplate", stripPrefix(handle, "Vk") + (handleIt->second.deletePool.empty() ? "" : "," + stripPrefix(handleIt->second.deletePool, "Vk")) },
+    { "deleterArg", handleIt->second.deletePool.empty() ? "allocator" : "allocateInfo." + startLowerCase(stripPrefix(handleIt->second.deletePool, "Vk")) },
+    { "class", stripPrefix(handle, "Vk") },
+    { "commandName", commandName }
+  });
+}
+
+void VulkanHppGenerator::writeFunctionBodyStandard(std::ostream & os, std::string const& indentation, std::pair<std::string, CommandData> const& commandData) const
+{
+  std::pair<bool, std::string> returnData = writeFunctionBodyStandardReturn(commandData.second.returnType);
+
+  assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
+  std::string const& handle = m_commandToHandle.find(commandData.first)->second;
+  assert(handle.empty() || (handle == commandData.second.params[0].type.type));
+
+  std::string arguments;
+  for (size_t i = handle.empty() ? 0 : 1; i < commandData.second.params.size(); i++)
+  {
+    if (0 < i)
+    {
+      arguments += ", ";
+    }
+    arguments += writeFunctionBodyStandardArgument(commandData.second.params[i].type, commandData.second.params[i].name);
+  }
+
+  std::string const standardTemplate =
+    R"(${i}  ${return}d.${command}( ${handleArg}${arguments} )${castClose};
+)";
+
+  os << replaceWithMap(standardTemplate,
+  {
+    { "i", indentation },
+    { "return", returnData.second },
+    { "command", commandData.first },
+    { "handleArg", handle.empty() ? "" : ("m_" + startLowerCase(stripPrefix(handle, "Vk"))) },
+    { "arguments", arguments },
+    { "castClose", returnData.first ? " )" : "" }
+  });
+}
+
+std::string VulkanHppGenerator::writeFunctionBodyStandardArgument(TypeData const& typeData, std::string const& name) const
+{
+  std::string argument;
+  if (beginsWith(typeData.type, "Vk"))
+  {
+    // the parameter is a vulkan type
+    if (!typeData.postfix.empty())
+    {
+      assert(typeData.postfix.back() == '*');
+      // it's a pointer -> need to reinterpret_cast it
+      argument += writeReinterpretCast(typeData.prefix.find("const") == 0, typeData.type, typeData.postfix.find("* const") != std::string::npos);
+    }
+    else
+    {
+      // it's a value -> need to static_cast ist
+      argument = "static_cast<" + typeData.type + ">";
+    }
+    argument += "( " + name + " )";
+  }
+  else
+  {
+    // it's a non-vulkan type -> just use it
+    argument = name;
+  }
+  return argument;
+}
+
+bool VulkanHppGenerator::writeFunctionHeaderArgumentEnhanced(std::ostream & os, ParamData const& param, size_t paramIndex, std::map<size_t, size_t> const& vectorParamIndices, bool skip, bool argEncountered, bool isTemplateParam, bool isLastArgument, bool singular, bool withDefaults, bool withAllocator) const
+{
+  if (!skip)
+  {
+    if (argEncountered)
+    {
+      os << ", ";
+    }
+    std::string strippedParameterName = startLowerCase(stripPrefix(param.name, "p"));
+
+    std::map<size_t, size_t>::const_iterator it = vectorParamIndices.find(paramIndex);
+    if (it == vectorParamIndices.end())
+    {
+      // the argument ist not a vector
+      if (param.type.postfix.empty())
+      {
+        // and its not a pointer -> just use its type and name here
+        writeFunctionHeaderArgumentEnhancedSimple(os, param, isLastArgument, withDefaults, withAllocator);
+      }
+      else
+      {
+        // the argument is not a vector, but a pointer
+        assert(param.type.postfix.back() == '*');
+        writeFunctionHeaderArgumentEnhancedPointer(os, param, strippedParameterName, withDefaults, withAllocator);
+      }
+    }
+    else
+    {
+      // the argument is a vector
+      writeFunctionHeaderArgumentEnhancedVector(os, param, strippedParameterName, it->second != INVALID_INDEX, isTemplateParam, singular, withDefaults, withAllocator);
+    }
+    argEncountered = true;
+  }
+  return argEncountered;
+}
+
+void VulkanHppGenerator::writeFunctionHeaderArgumentEnhancedPointer(std::ostream & os, ParamData const& param, std::string const& strippedParameterName, bool withDefaults, bool withAllocator) const
+{
+  assert(param.type.postfix.back() == '*');
+  if (param.optional)
+  {
+    // for an optional argument, trim the leading 'p' from the name
+    os << "Optional<" << param.type.prefix << (param.type.prefix.empty() ? "" : " ") << stripPrefix(param.type.type, "Vk") << "> " << strippedParameterName;
+    if (withDefaults && !withAllocator)
+    {
+      os << " = nullptr";
+    }
+  }
+  else if (param.type.type == "void")
+  {
+    // for void-pointer, just use type and name
+    os << param.type.compose() << " " << param.name;
+  }
+  else if (param.type.type != "char")
+  {
+    // for non-char-pointer, change to reference
+    assert(param.type.postfix == "*");
+    os << param.type.prefix << (param.type.prefix.empty() ? "" : " ") << stripPrefix(param.type.type, "Vk") << " & " << strippedParameterName;
+  }
+  else
+  {
+    // for char-pointer, change to const reference to std::string
+    os << "const std::string & " << strippedParameterName;
+  }
+}
+
+void VulkanHppGenerator::writeFunctionHeaderArgumentEnhancedSimple(std::ostream & os, ParamData const& param, bool lastArgument, bool withDefaults, bool withAllocator) const
+{
+  os << param.type.compose() << " " << param.name;
+  if (!param.arraySize.empty())
+  {
+    os << "[" << param.arraySize << "]";
+  }
+
+  if (withDefaults && lastArgument && !withAllocator)
+  {
+    // check if the very last argument is a flag without any bits -> provide some empty default for it
+    std::map<std::string, BitmaskData>::const_iterator bitmasksIt = m_bitmasks.find(param.type.type);
+    if (bitmasksIt != m_bitmasks.end())
+    {
+      // get the enum corresponding to this flag, to check if it's empty
+      std::string strippedBitmaskName = stripPrefix(bitmasksIt->first, "Vk");
+      std::map<std::string, EnumData>::const_iterator enumIt = m_bitmaskBits.find(bitmasksIt->second.requires);
+      assert(enumIt != m_bitmaskBits.end());
+      if (enumIt->second.values.empty())
+      {
+        // there are no bits in this flag -> provide the default
+        os << " = " << stripPrefix(param.type.type, "Vk") << "()";
+      }
+    }
+  }
+}
+
+void VulkanHppGenerator::writeFunctionHeaderArgumentEnhancedVector(std::ostream & os, ParamData const& param, std::string const& strippedParameterName, bool hasSizeParam, bool isTemplateParam, bool singular, bool withDefaults, bool withAllocator) const
+{
+  assert(param.type.postfix.back() == '*');
+
+  // it's optional, if it's marked as optional and there's no size specified
+  bool optional = param.optional && !hasSizeParam;
+  if (param.type.type.find("char") != std::string::npos)
+  {
+    // it's a char-vector -> use a std::string (either optional or a const-reference
+    if (optional)
+    {
+      os << "Optional<const std::string> " << strippedParameterName;
+      if (withDefaults && !withAllocator)
+      {
+        os << " = nullptr";
+      }
+    }
+    else
+    {
+      os << "const std::string & " << strippedParameterName;
+    }
+  }
+  else
+  {
+    // it's a non-char vector (they are never optional)
+    assert(!optional);
+    if (singular)
+    {
+      // in singular case, change from pointer to reference
+      os << param.type.prefix << (param.type.prefix.empty() ? "" : " ") << stripPrefix(param.type.type, "Vk") << " & " << stripPluralS(strippedParameterName);
+    }
+    else
+    {
+      // otherwise, use our ArrayProxy
+      bool isConst = (param.type.prefix.find("const") != std::string::npos);
+      os << "ArrayProxy<" << (isTemplateParam ? (isConst ? "const T" : "T") : stripPostfix(param.type.compose(), "*")) << "> " << strippedParameterName;
+    }
+  }
+}
+
+void VulkanHppGenerator::writeFunctionHeaderArguments(std::ostream & os, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool enhanced, bool singular, bool withDefaults, bool withAllocator) const
+{
+  os << "(";
+  if (enhanced)
+  {
+    writeFunctionHeaderArgumentsEnhanced(os, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, singular, withDefaults, withAllocator);
+  }
+  else
+  {
+    writeFunctionHeaderArgumentsStandard(os, commandData, withDefaults);
+  }
+  os << ")";
+
+  assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
+  if (!m_commandToHandle.find(commandData.first)->second.empty())
+  {
+    os << " const";
+  }
+}
+
+void VulkanHppGenerator::writeFunctionHeaderArgumentsEnhanced(std::ostream & os, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular, bool withDefaults, bool withAllocator) const
+{
+  assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
+  std::string const& handle = m_commandToHandle.find(commandData.first)->second;
+
+  // check if there's at least one argument left to put in here
+  std::set<size_t> skippedParams = determineSkippedParams(returnParamIndex, vectorParamIndices);
+  if (skippedParams.size() + (handle.empty() ? 0 : 1) < commandData.second.params.size())
+  {
+    // determine the last argument, where we might provide some default for
+    size_t lastArgument = INVALID_INDEX;
+    for (size_t i = commandData.second.params.size() - 1; i < commandData.second.params.size(); i--)
+    {
+      if (skippedParams.find(i) == skippedParams.end())
+      {
+        lastArgument = i;
+        break;
+      }
+    }
+
+    os << " ";
+    bool argEncountered = false;
+    for (size_t i = handle.empty() ? 0 : 1; i < commandData.second.params.size(); i++)
+    {
+      argEncountered = writeFunctionHeaderArgumentEnhanced(os, commandData.second.params[i], i, vectorParamIndices, skippedParams.find(i) != skippedParams.end(), argEncountered, (templateParamIndex == i), (lastArgument == i), singular, withDefaults, withAllocator);
+    }
+
+    if (argEncountered)
+    {
+      os << ", ";
+    }
+  }
+  if (withAllocator)
+  {
+    os << "Allocator const& vectorAllocator, ";
+  }
+  os << "Dispatch const &d";
+  if (withDefaults && !withAllocator)
+  {
+    os << " = Dispatch()";
+  }
+
+  os << " ";
+}
+
+void VulkanHppGenerator::writeFunctionHeaderArgumentsStandard(std::ostream & os, std::pair<std::string, CommandData> const& commandData, bool withDefaults) const
+{
+  // for the standard case, just list all the arguments as we've got them
+  // determine the last argument, where we might provide some default for
+  size_t lastArgument = commandData.second.params.size() - 1;
+
+  assert(m_commandToHandle.find(commandData.first) != m_commandToHandle.end());
+  std::string const& handle = m_commandToHandle.find(commandData.first)->second;
+
+  bool argEncountered = false;
+  for (size_t i = handle.empty() ? 0 : 1; i < commandData.second.params.size(); i++)
+  {
+    argEncountered = writeFunctionHeaderArgumentStandard(os, commandData.second.params[i], argEncountered, lastArgument == i, withDefaults);
+  }
+  if (argEncountered)
+  {
+    os << ", ";
+  }
+
+  os << "Dispatch const &d";
+  if (withDefaults)
+  {
+    os << " = Dispatch() ";
+  }
+}
+
+bool VulkanHppGenerator::writeFunctionHeaderArgumentStandard(std::ostream & os, ParamData const& param, bool argEncountered, bool isLastArgument, bool withDefaults) const
+{
+  if (argEncountered)
+  {
+    os << ",";
+  }
+
+  os << " " << param.type.compose() << " " << param.name;
+  if (!param.arraySize.empty())
+  {
+    os << "[" << param.arraySize << "]";
+  }
+
+  if (withDefaults && isLastArgument)
+  {
+    // check if the very last argument is a flag without any bits -> provide some empty default for it
+    std::map<std::string, BitmaskData>::const_iterator bitmasksIt = m_bitmasks.find(param.type.type);
+    if (bitmasksIt != m_bitmasks.end())
+    {
+      // get the enum corresponding to this flag, to check if it's empty
+      std::string strippedBitmaskName = stripPrefix(bitmasksIt->first, "Vk");
+      std::map<std::string, EnumData>::const_iterator enumIt = m_bitmaskBits.find(bitmasksIt->second.requires);
+      assert(enumIt != m_bitmaskBits.end());
+      if (enumIt->second.values.empty())
+      {
+        // there are no bits in this flag -> provide the default
+        os << " = " << stripPrefix(param.type.type, "Vk") << "()";
+      }
+    }
+  }
+  return true;
+}
+
+void VulkanHppGenerator::writeFunctionHeaderReturnType(std::ostream & os, CommandData const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, std::string const& enhancedReturnType, bool enhanced, bool singular, bool unique, bool isStructureChain) const
+{
+  std::string templateString;
+  std::string returnType;
+  if (enhanced)
+  {
+    // the enhanced function might return some pretty complex return stuff
+    bool isVector = (enhancedReturnType.find("Allocator") != std::string::npos);
+    if (isStructureChain || (!singular && isVector))
+    {
+      // for the non-singular case with allocation, we need to prepend with 'typename' to keep compilers happy
+      templateString = "typename ";
+    }
+    if (unique)
+    {
+      // the unique version returns something prefixed with 'Unique'; potentially a vector of that stuff
+      // it's a vector, if it's not the singular version and the return parameter is a vector parameter
+      bool returnsVector = !singular && (vectorParamIndices.find(returnParamIndex) != vectorParamIndices.end());
+
+      templateString += returnsVector ? "ResultValueType<std::vector<UniqueHandle<${returnType},Dispatch>,Allocator>>::type " : "typename ResultValueType<UniqueHandle<${returnType},Dispatch>>::type ";
+      returnType = isStructureChain ? "StructureChain<X, Y, Z...>" : stripPrefix(commandData.params[returnParamIndex].type.type, "Vk");
+    }
+    else if ((enhancedReturnType != stripPrefix(commandData.returnType, "Vk")) && (commandData.returnType != "void"))
+    {
+      // if the enhanced return type differs from the original return type, and it's not void, we return a ResultValueType<...>::type
+      templateString += "ResultValueType<${returnType}>::type ";
+
+      assert(commandData.returnType == "VkResult");
+      // in singular case, we create the ResultValueType from the pure return type, otherwise from the enhanced return type
+      returnType = isStructureChain ? "StructureChain<X, Y, Z...>" : (singular ? stripPrefix(commandData.params[returnParamIndex].type.type, "Vk") : enhancedReturnType);
+    }
+    else if ((returnParamIndex != INVALID_INDEX) && (1 < commandData.successCodes.size()))
+    {
+      // if there is a return parameter at all, and there are multiple success codes, we return a ResultValue<...> with the pure return type
+      assert(commandData.returnType == "VkResult");
+      templateString = "ResultValue<${returnType}> ";
+      returnType = isStructureChain ? "StructureChain<X, Y, Z...>" : stripPrefix(commandData.params[returnParamIndex].type.type, "Vk");
+    }
+    else
+    {
+      // and in every other case, we just return the enhanced return type.
+      templateString = "${returnType} ";
+      returnType = isStructureChain && !isVector ? "StructureChain<X, Y, Z...>" : enhancedReturnType;
+    }
+  }
+  else
+  {
+    // the non-enhanced function just uses the return type
+    templateString = "${returnType} ";
+    returnType = stripPrefix(commandData.returnType, "Vk");
+  }
+  os << replaceWithMap(templateString, { { "returnType", returnType } });
+}
+
+void VulkanHppGenerator::writeFunctionHeaderTemplate(std::ostream & os, std::string const& indentation, size_t returnParamIndex, size_t templateParamIndex, std::string const& enhancedReturnType, bool enhanced, bool singular, bool unique, bool withDefault, bool isStructureChain) const
+{
+  bool withAllocator = (enhancedReturnType.find("Allocator") != std::string::npos);
+  os << indentation << "template<";
+  if (enhanced)
+  {
+    if (isStructureChain)
+    {
+      os << "typename " << (withAllocator ? "StructureChain" : "X, typename Y, typename ...Z") << ", ";
+    }
+    else if ((templateParamIndex != INVALID_INDEX) && ((templateParamIndex != returnParamIndex) || (enhancedReturnType == "Result")))
+    {
+      assert(!withAllocator);
+      os << "typename T, ";
+    }
+    if (!singular && withAllocator)
+    {
+      // otherwise, if there's an Allocator used in the enhanced return type, we templatize on that Allocator
+      assert((enhancedReturnType.substr(0, 12) == "std::vector<") && (enhancedReturnType.find(',') != std::string::npos) && (12 < enhancedReturnType.find(',')));
+      os << "typename Allocator";
+      if (withDefault)
+      {
+        // for the default type get the type from the enhancedReturnType, which is of the form 'std::vector<Type,Allocator>'
+        assert(!isStructureChain || !unique);
+        os << " = std::allocator<" << (isStructureChain ? "StructureChain" : (unique ? "Unique" : "") + enhancedReturnType.substr(12, enhancedReturnType.find(',') - 12)) << ">";
+      }
+      os << ", ";
+    }
+  }
+  os << "typename Dispatch" << (withDefault ? " = DispatchLoaderStatic" : "") << ">" << std::endl;
+}
+
+void VulkanHppGenerator::writeHandle(std::ostream & os, std::pair<std::string, HandleData> const& handleData, std::set<std::string> & listedHandles) const
+{
+  if (listedHandles.find(handleData.first) == listedHandles.end())
+  {
+    listedHandles.insert(handleData.first);
+
+    // first check for any handle that needs to be listed before this one
+    for (auto const& command : handleData.second.commands)
+    {
+      for (auto const& parameter : command.second.params)
+      {
+        std::string typeName = parameter.type.type;
+        auto handlesIt = m_handles.find(typeName);
+        if ((handlesIt != m_handles.end()) && (listedHandles.find(typeName) == listedHandles.end()))
+        {
+          writeHandle(os, *handlesIt, listedHandles);
+        }
+      }
+    }
+
+    if (handleData.first.empty())
+    {
+      for (auto const& command : handleData.second.commands)
+      {
+        std::string commandName = determineCommandName(command.first, command.second.params[0].type.type);
+        if (command.first == "vkCreateInstance")
+        {
+          // special handling for createInstance, as we need to explicitly place the forward declarations and the deleter classes here
+#if !defined(NDEBUG)
+          auto handleIt = m_handles.find("");
+          assert((handleIt != m_handles.end()) && (handleIt->second.childrenHandles.size() == 2));
+          assert(handleIt->second.childrenHandles.find("VkInstance") != handleIt->second.childrenHandles.end());
+#endif
+
+          writeUniqueTypes(os, "", { "VkInstance" });
+        }
+        writeCommand(os, "  ", commandName, command, false);
+      }
+    }
+    else
+    {
+      // then write any forward declaration of Deleters used by this handle
+      if (!handleData.second.childrenHandles.empty())
+      {
+        writeUniqueTypes(os, handleData.first, handleData.second.childrenHandles);
+      }
+      else if (handleData.first == "VkPhysicalDevice")
+      {
+        // special handling for class Device, as it's created from PhysicalDevice, but destroys itself
+        writeUniqueTypes(os, "", { "VkDevice" });
+      }
+
+      std::ostringstream commands;
+      // list all the commands that are mapped to members of this class
+      for (auto const& command : handleData.second.commands)
+      {
+        std::string commandName = determineCommandName(command.first, command.second.params[0].type.type);
+        writeCommand(commands, "    ", commandName, command, false);
+
+        // special handling for destroy functions which are not aliased.
+        if (!command.second.isAlias && (((command.first.substr(2, 7) == "Destroy") && (commandName != "destroy")) || (command.first.substr(2, 4) == "Free")))
+        {
+          commandName = (command.first.substr(2, 7) == "Destroy") ? "destroy" : "free";
+          writeCommand(commands, "    ", commandName, command, false);
+        }
+      }
+
+      static const std::string templateString = R"(
+  class ${className}
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR ${className}()
+      : m_${memberName}(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR ${className}( std::nullptr_t )
+      : m_${memberName}(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT ${className}( Vk${className} ${memberName} )
+      : m_${memberName}( ${memberName} )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    ${className} & operator=(Vk${className} ${memberName})
+    {
+      m_${memberName} = ${memberName};
+      return *this; 
+    }
+#endif
+
+    ${className} & operator=( std::nullptr_t )
+    {
+      m_${memberName} = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( ${className} const & rhs ) const
+    {
+      return m_${memberName} == rhs.m_${memberName};
+    }
+
+    bool operator!=(${className} const & rhs ) const
+    {
+      return m_${memberName} != rhs.m_${memberName};
+    }
+
+    bool operator<(${className} const & rhs ) const
+    {
+      return m_${memberName} < rhs.m_${memberName};
+    }
+${commands}
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator Vk${className}() const
+    {
+      return m_${memberName};
+    }
+
+    explicit operator bool() const
+    {
+      return m_${memberName} != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_${memberName} == VK_NULL_HANDLE;
+    }
+
+  private:
+    Vk${className} m_${memberName};
+  };
+  static_assert( sizeof( ${className} ) == sizeof( Vk${className} ), "handle and wrapper have different size!" );
+)";
+
+      os << replaceWithMap(templateString, {
+        { "className", stripPrefix(handleData.first, "Vk") },
+        { "memberName", startLowerCase(stripPrefix(handleData.first, "Vk")) },
+        { "commands", commands.str() }
+      });
+
+#if 0
+      // and finally the commands, that are member functions of this handle
+      for (auto const& command : handleData.second.commands)
+      {
+        std::string commandName = determineCommandName(command.first, command.second.params[0].type.type);
+        std::string strippedName = startLowerCase(stripPrefix(command.first, "vk"));
+        writeCommand(os, "  ", commandName, command, true);
+
+        // special handling for destroy functions
+        if (!command.second.isAlias && (((command.first.substr(2, 7) == "Destroy") && (commandName != "destroy")) || (command.first.substr(2, 4) == "Free")))
+        {
+          commandName = (command.first.substr(2, 7) == "Destroy") ? "destroy" : "free";
+          writeCommand(os, "  ", commandName, command, true);
+        }
+      }
+#endif
+
+      if (!handleData.second.alias.empty())
+      {
+        os << "  using " << stripPrefix(handleData.second.alias, "Vk") << " = " << stripPrefix(handleData.first, "Vk") << ";" << std::endl;
+      }
+    }
+  }
+}
+
+void VulkanHppGenerator::writeHandles(std::ostream & os) const
+{
+  std::set<std::string> listedHandles;
+  for (auto const& handle : m_handles)
+  {
+    writeHandle(os, handle, listedHandles);
+  }
+}
+
+void VulkanHppGenerator::writeHandlesCommandDefintions(std::ostream & os) const
+{
+  for (auto const& handle : m_handles)
+  {
+    // finally the commands, that are member functions of this handle
+    for (auto const& command : handle.second.commands)
+    {
+      std::string commandName = determineCommandName(command.first, command.second.params[0].type.type);
+      std::string strippedName = startLowerCase(stripPrefix(command.first, "vk"));
+      writeCommand(os, "  ", commandName, command, true);
+
+      // special handling for destroy functions
+      if (!command.second.isAlias && (((command.first.substr(2, 7) == "Destroy") && (commandName != "destroy")) || (command.first.substr(2, 4) == "Free")))
+      {
+        commandName = (command.first.substr(2, 7) == "Destroy") ? "destroy" : "free";
+        writeCommand(os, "  ", commandName, command, true);
+      }
+    }
+  }
+  os << std::endl;
+}
+
+// Intended only for `enum class Result`!
+void VulkanHppGenerator::writeResultExceptions(std::ostream & os) const
+{
+  std::string templateString = R"(
+  class ${className} : public SystemError
+  {
+  public:
+    ${className}( std::string const& message )
+      : SystemError( make_error_code( ${enumName}::${enumMemberName} ), message ) {}
+    ${className}( char const * message )
+      : SystemError( make_error_code( ${enumName}::${enumMemberName} ), message ) {}
+  };
+)";
+
+  auto enumData = m_enums.find("VkResult");
+  for (auto const& value : enumData->second.values)
+  {
+    if (beginsWith(value.second, "eError"))
+    {
+      os << replaceWithMap(templateString,
+      {
+        { "className", stripPrefix(value.second, "eError") + "Error" },
+        { "enumName", stripPrefix(enumData->first, "Vk") },
+        { "enumMemberName", value.second }
+      });
+    }
+  }
+  os << std::endl;
+}
+
+void VulkanHppGenerator::writeStruct(std::ostream & os, std::pair<std::string, StructureData> const& structure, std::set<std::string> & listedStructures) const
+{
+  if (listedStructures.find(structure.first) == listedStructures.end())
+  {
+    listedStructures.insert(structure.first);
+    for (auto const& member : structure.second.members)
+    {
+      auto structureIt = m_structures.find(member.type.type);
+      if ((structureIt != m_structures.end()) && (listedStructures.find(member.type.type) == listedStructures.end()))
+      {
+        writeStruct(os, *structureIt, listedStructures);
+      }
+    }
+    if (!structure.second.subStruct.empty())
+    {
+      auto structureIt = m_structures.find(structure.second.subStruct);
+      if ((structureIt != m_structures.end()) && (listedStructures.find(structureIt->first) == listedStructures.end()))
+      {
+        writeStruct(os, *structureIt, listedStructures);
+      }
+    }
+
+    if (structure.second.isUnion)
+    {
+      writeUnion(os, structure);
+    }
+    else
+    {
+      writeStructure(os, structure);
+    }
+  }
+}
+
+void VulkanHppGenerator::writeStructCompareOperators(std::ostream & os, std::pair<std::string, StructureData> const& structData) const
+{
+  // two structs are compared by comparing each of the elements
+  std::string compareMembers;
+  std::string intro = "";
+  for (auto const& member : structData.second.members)
+  {
+    const std::string compareMemberTemplate = std::string("${intro}") + (member.arraySize.empty() ? "( ${name} == rhs.${name} )" : "( memcmp( ${name}, rhs.${name}, ${size} * sizeof( ${type} ) ) == 0 )");
+    compareMembers += replaceWithMap(compareMemberTemplate,
+    {
+      { "intro", intro },
+      { "name", member.name },
+      { "size", member.arraySize },
+      { "type", member.type.compose() }
+    });
+    intro = "\n          && ";
+  }
+
+  static const std::string compareTemplate = R"(
+    bool operator==( ${name} const& rhs ) const
+    {
+      return ${compareMembers};
+    }
+
+    bool operator!=( ${name} const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+)";
+
+  os << replaceWithMap(compareTemplate, { { "name", stripPrefix(structData.first, "Vk") }, { "compareMembers", compareMembers } });
+}
+
+void VulkanHppGenerator::writeStructConstructor(std::ostream & os, std::pair<std::string, StructureData> const& structData) const
+{
+  // the constructor with all the elements as arguments, with defaults
+  std::string ctorOpening = "    " + stripPrefix(structData.first, "Vk") + "( ";
+  std::string indentation(ctorOpening.size(), ' ');
+
+  std::string arguments, initializers, copyOps;
+  bool listedArgument = false;
+  bool firstArgument = true;
+  for (auto const& member : structData.second.members)
+  {
+    // gather the arguments
+    arguments += writeStructConstructorArgument(listedArgument, indentation, member);
+
+    // gather the initializers; skip members 'pNext' and 'sType', they are directly set by initializers
+    if ((member.name != "pNext") && (member.name != "sType"))
+    {
+      if (member.arraySize.empty())
+      {
+        // here, we can only handle non-array arguments
+        static const std::string templateString = "      ${sep} ${memberName}( ${value} )\n";
+        initializers += replaceWithMap(templateString, { { "sep", firstArgument ? ":" : "," },{ "memberName", member.name },{ "value", member.name + "_" } });
+        firstArgument = false;
+      }
+      else
+      {
+        // here we can handle the arrays, copying over from argument (with trailing '_') to member
+        // size is arraySize times sizeof type
+        static const std::string templateString = "\n      memcpy( &${member}, ${member}_.data(), ${arraySize} * sizeof( ${type} ) );";
+        copyOps += replaceWithMap(templateString, { { "member", member.name },{ "arraySize", member.arraySize },{ "type", member.type.compose() } });
+      }
+    }
+  }
+  if (!copyOps.empty())
+  {
+    copyOps += "\n    ";
+  }
+
+  std::ostringstream subStructConstructor;
+  if (!structData.second.subStruct.empty())
+  {
+    auto const& subStruct = m_structures.find(structData.second.subStruct);
+    assert(subStruct != m_structures.end());
+
+    std::string subStructArgumentName = startLowerCase(stripPrefix(subStruct->first, "Vk"));
+    ctorOpening = "    explicit " + stripPrefix(structData.first, "Vk") + "( ";
+    indentation = std::string(ctorOpening.size(), ' ');
+
+    static const std::string copyTemplate = "      ${sep} ${member}( ${value} )\n";
+    std::string subCopies;
+    firstArgument = true;
+    for (size_t i = 0; i < subStruct->second.members.size(); i++)
+    {
+      assert(structData.second.members[i].arraySize.empty());
+      subCopies += replaceWithMap(copyTemplate,
+      {
+        { "sep", firstArgument ? ":" : "," },
+        { "member", structData.second.members[i].name },
+        { "value", subStructArgumentName + "." + subStruct->second.members[i].name }
+      });
+      firstArgument = false;
+    }
+
+    std::string subArguments;
+    listedArgument = true;
+    for (size_t i = subStruct->second.members.size(); i < structData.second.members.size(); i++)
+    {
+      subArguments += writeStructConstructorArgument(listedArgument, indentation, structData.second.members[i]);
+
+      assert(structData.second.members[i].arraySize.empty());
+      subCopies += replaceWithMap(copyTemplate, { { "sep", "," }, { "member", structData.second.members[i].name }, { "value", structData.second.members[i].name + "_" } });
+    }
+
+    std::string constructorTemplate = R"(
+    explicit ${type}( ${subType} const& ${subTypeName}${subArguments} )
+${subCopies}    {}
+)";
+    subStructConstructor << replaceWithMap(constructorTemplate,
+    {
+      { "type", stripPrefix(structData.first, "Vk") },
+      { "subType", stripPrefix(subStruct->first, "Vk") },
+      { "subTypeName", subStructArgumentName },
+      { "subArguments", subArguments },
+      { "subCopies", subCopies }
+    });
+  }
+
+  static std::string constructorTemplate = R"(    ${name}( ${arguments} )
+${initializers}    {${copyOps}}
+${subStructConstructor}
+    ${name}( Vk${name} const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ${name} ) );
+    }
+
+    ${name}& operator=( Vk${name} const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ${name} ) );
+      return *this;
+    }
+)";
+
+  os << replaceWithMap(constructorTemplate,
+  {
+    { "name", stripPrefix(structData.first, "Vk") },
+    { "arguments", arguments },
+    { "initializers", initializers },
+    { "copyOps", copyOps },
+    { "subStructConstructor", subStructConstructor.str() }
+  });
+}
+
+std::string VulkanHppGenerator::writeStructConstructorArgument(bool & listedArgument, std::string const& indentation, MemberData const& memberData) const
+{
+  std::string argument;
+
+  // skip members 'pNext' and 'sType', as they are never explicitly set
+  if ((memberData.name != "pNext") && (memberData.name != "sType"))
+  {
+    static const std::string simpleArgumentTemplate = "${type} ${name} = ${value}";
+    static const std::string arrayArgumentTemplate = "std::array<${type},${size}> const& ${name} = { { ${value} } }";
+    const std::string argumentTemplate = "${intro}" + (memberData.arraySize.empty() ? simpleArgumentTemplate : arrayArgumentTemplate);
+    argument = replaceWithMap(argumentTemplate,
+    {
+      { "intro", listedArgument ? (",\n" + indentation) : "" },
+      { "type", memberData.type.compose() },
+      { "size", memberData.arraySize },
+      { "name", memberData.name + "_" },
+      { "value", (memberData.arraySize.empty() && (!memberData.type.postfix.empty() && memberData.type.postfix.back() == '*')) ? "nullptr" : defaultValue(memberData.type.type) }
+    });
+
+    listedArgument = true;
+  }
+  return argument;
+}
+
+void VulkanHppGenerator::writeStructMembers(std::ostream & os, StructureData const& structData) const
+{
+  auto enumIt = m_enums.find("VkStructureType");
+  assert(enumIt != m_enums.end());
+  for (auto const& member : structData.members)
+  {
+    if (member.type.type == "VkStructureType")
+    {
+      assert(member.name == "sType");
+      if (!member.values.empty())
+      {
+        assert(!member.values.empty() && beginsWith(member.values, "VK_STRUCTURE_TYPE"));
+        auto nameIt = std::find_if(enumIt->second.values.begin(), enumIt->second.values.end(), [&member](std::pair<std::string, std::string> const& value) { return member.values == value.first; });
+        assert(nameIt != enumIt->second.values.end());
+        os << "  private:" << std::endl
+          << "    StructureType sType = StructureType::" << nameIt->second << ";" << std::endl
+          << std::endl
+          << "  public:" << std::endl;
+      }
+      else
+      {
+        os << "    StructureType sType;" << std::endl;
+      }
+    }
+    else
+    {
+      os << "    " << member.type.compose() << " " << member.name;
+      if (member.name == "pNext")
+      {
+        os << " = nullptr";
+      }
+      else if (!member.arraySize.empty())
+      {
+        os << "[" << member.arraySize << "]";
+      }
+      os << ";" << std::endl;
+    }
+  }
+}
+
+void VulkanHppGenerator::writeStructs(std::ostream & os) const
+{
+  std::set<std::string> listedStructures;
+  for (auto const& structure : m_structures)
+  {
+    writeStruct(os, structure, listedStructures);
+  }
+}
+
+void VulkanHppGenerator::writeStructSetter(std::ostream & os, std::string const& structureName, MemberData const& memberData) const
+{
+  if (memberData.type.type != "VkStructureType") // filter out StructureType, which is supposed to be immutable !
+  {
+    // copy over the argument, either by assigning simple data, or by memcpy array data
+    const std::string copyOpTemplate = memberData.arraySize.empty() ? "${name} = ${name}_" : "memcpy( ${name}, ${name}_.data(), ${size} * sizeof( ${type} ) )";
+    std::string copyOp = replaceWithMap(copyOpTemplate, { { "name", memberData.name }, { "size", memberData.arraySize }, { "type", memberData.type.compose() } });
+
+    // the setters return a reference to the structure
+    static const std::string setterTemplate = R"(
+    ${structureName} & ${functionName}( ${memberType} ${memberName}_ )
+    {
+      ${copyOp};
+      return *this;
+    }
+)";
+
+    os << replaceWithMap(setterTemplate,
+    {
+      { "structureName", structureName },
+      { "functionName", "set" + startUpperCase(memberData.name) },
+      { "memberType", memberData.arraySize.empty() ? memberData.type.compose() : "std::array<" + memberData.type.compose() + "," + memberData.arraySize + ">" },
+      { "memberName", memberData.name },
+      { "copyOp", copyOp }
+    });
+  }
+}
+
+void VulkanHppGenerator::writeStructure(std::ostream & os, std::pair<std::string, StructureData> const& structure) const
+{
+  // only structs that are not returnedOnly get a constructor!
+  std::ostringstream constructorAndSetters;
+  if (!structure.second.returnedOnly)
+  {
+    constructorAndSetters << std::endl;
+    writeStructConstructor(constructorAndSetters, structure);
+    for (auto const& member : structure.second.members)
+    {
+      writeStructSetter(constructorAndSetters, stripPrefix(structure.first, "Vk"), member);
+    }
+  }
+
+  // operator==() and operator!=()
+  // only structs without a union as a member can have a meaningfull == and != operation; we filter them out
+  std::ostringstream compareOperators;
+  if (!containsUnion(structure.first))
+  {
+    writeStructCompareOperators(compareOperators, structure);
+  }
+
+  // the member variables
+  std::ostringstream members;
+  writeStructMembers(members, structure.second);
+
+  static const std::string structureTemplate = R"(
+${enterProtect}  struct ${name}
+  {${constructorAndSetters}
+    operator ${vkName} const&() const
+    {
+      return *reinterpret_cast<const ${vkName}*>( this );
+    }
+
+    operator ${vkName} &()
+    {
+      return *reinterpret_cast<${vkName}*>( this );
+    }
+${compareOperators}
+${members}  };
+  static_assert( sizeof( ${name} ) == sizeof( ${vkName} ), "struct and wrapper have different size!" );
+${leaveProtect})";
+
+  os << replaceWithMap(structureTemplate,
+  {
+    { "enterProtect", structure.second.protect.empty() ? "" : ("#ifdef " + structure.second.protect + "\n") },
+    { "name", stripPrefix(structure.first, "Vk") },
+    { "constructorAndSetters", constructorAndSetters.str() },
+    { "vkName", structure.first },
+    { "compareOperators", compareOperators.str() },
+    { "members", members.str() },
+    { "leaveProtect", structure.second.protect.empty() ? "" : ("#endif /*" + structure.second.protect + "*/\n") }
+  });
+}
+
+void VulkanHppGenerator::writeStructureChainValidation(std::ostream & os)
+{
+  // write all template functions for the structure pointer chain validation
+  for (auto const& structure : m_structures)
+  {
+    if (!structure.second.structExtends.empty())
+    {
+      enterProtect(os, structure.second.protect);
+
+      // write out allowed structure chains
+      for (auto extendName : structure.second.structExtends)
+      {
+        std::map<std::string, StructureData>::const_iterator itExtend = m_structures.find(extendName);
+        if (itExtend == m_structures.end())
+        {
+          std::stringstream errorString;
+          errorString << extendName << " does not specify a struct in structextends field.";
+
+          // check if symbol name is an alias to a struct
+          auto itAlias = std::find_if(m_structures.begin(), m_structures.end(), [&extendName](std::pair<std::string, StructureData> const &it) -> bool {return it.second.alias == extendName; });
+          if (itAlias != m_structures.end())
+          {
+            errorString << " The symbol is an alias and maps to " << itAlias->first << ".";
+          }
+
+          errorString << std::endl;
+          throw std::runtime_error(errorString.str());
+        }
+        if (structure.second.protect != itExtend->second.protect)
+        {
+          enterProtect(os, itExtend->second.protect);
+        }
+
+        os << "  template <> struct isStructureChainValid<" << stripPrefix(extendName, "Vk") << ", " << stripPrefix(structure.first, "Vk") << ">{ enum { value = true }; };" << std::endl;
+
+        if (structure.second.protect != itExtend->second.protect)
+        {
+          leaveProtect(os, itExtend->second.protect);
+        }
+      }
+      leaveProtect(os, structure.second.protect);
+    }
+  }
+}
+
+void VulkanHppGenerator::writeThrowExceptions(std::ostream & os) const
+{
+  auto enumData = m_enums.find("VkResult");
+
+  std::string casesString;
+  for (auto const& value : enumData->second.values)
+  {
+    if (beginsWith(value.second, "eError"))
+    {
+      casesString += "      case Result::" + value.second + ": throw " + stripPrefix(value.second, "eError") + "Error( message );\n";
+    }
+  }
+
+  static const std::string exceptionTemplate = R"(
+  VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
+  {
+    switch ( result )
+    {
+${cases}      default: throw SystemError( make_error_code( result ) );
+    }
+  }
+)";
+  os << replaceWithMap(exceptionTemplate, { { "cases", casesString } });
+}
+
+void VulkanHppGenerator::writeUnion(std::ostream & os, std::pair<std::string, StructureData> const& structure) const
+{
+  std::ostringstream oss;
+  os << std::endl
+    << "  union " << stripPrefix(structure.first, "Vk") << std::endl
+    << "  {" << std::endl;
+
+  bool firstTime = true;
+  for (auto const& member : structure.second.members)
+  {
+    // one constructor per union element
+    os << "    " << stripPrefix(structure.first, "Vk") << "( " << (member.arraySize.empty() ? (member.type.compose() + " ") : ("const std::array<" + member.type.compose() + "," + member.arraySize + ">& ")) << member.name << "_";
+
+    // just the very first constructor gets default arguments
+    if (firstTime)
+    {
+      std::string value = defaultValue(member.type.type);
+      os << (member.arraySize.empty() ? (" = " + value) : (" = { { " + value + " } }"));
+      firstTime = false;
+    }
+    os << " )" << std::endl
+      << "    {" << std::endl
+      << "      " << (member.arraySize.empty() ? (member.name + " = " + member.name + "_") : ("memcpy( " + member.name + ", " + member.name + "_.data(), " + member.arraySize + " * sizeof( " + member.type.compose() + " ) )")) << ";" << std::endl
+      << "    }" << std::endl
+      << std::endl;
+  }
+
+  // one setter per union element
+  assert(!structure.second.returnedOnly);
+  for (auto const& member : structure.second.members)
+  {
+    writeStructSetter(os, stripPrefix(structure.first, "Vk"), member);
+  }
+
+  // the implicit cast operators to the native type
+  os << "    operator " << structure.first << " const&() const" << std::endl
+    << "    {" << std::endl
+    << "      return *reinterpret_cast<const " << structure.first << "*>(this);" << std::endl
+    << "    }" << std::endl
+    << std::endl
+    << "    operator " << structure.first << " &()" << std::endl
+    << "    {" << std::endl
+    << "      return *reinterpret_cast<" << structure.first << "*>(this);" << std::endl
+    << "    }" << std::endl
+    << std::endl;
+
+  // the union member variables
+  // if there's at least one Vk... type in this union, check for unrestricted unions support
+  bool needsUnrestrictedUnions = (std::find_if(structure.second.members.begin(), structure.second.members.end(), [](MemberData const& member) { return beginsWith(member.type.type, "Vk"); }) != structure.second.members.end());
+  if (needsUnrestrictedUnions)
+  {
+    os << "#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS" << std::endl;
+    for (auto const& member : structure.second.members)
+    {
+      os << "    " << member.type.compose() << " " << member.name << (member.arraySize.empty() ? "" : ("[" + member.arraySize + "]")) << ";" << std::endl;
+    }
+    os << "#else" << std::endl;
+  }
+  for (auto const& member : structure.second.members)
+  {
+    os << "    " << (beginsWith(member.type.type, "Vk") ? "Vk" : "") << member.type.compose() << " " << member.name << (member.arraySize.empty() ? "" : ("[" + member.arraySize + "]")) << ";" << std::endl;
+  }
+  if (needsUnrestrictedUnions)
+  {
+    os << "#endif  /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/" << std::endl;
+  }
+  os << "  };" << std::endl;
+}
+
+void VulkanHppGenerator::writeUniqueTypes(std::ostream &os, std::string const& parentType, std::set<std::string> const& childrenTypes) const
+{
+  os << std::endl
+    << "#ifndef VULKAN_HPP_NO_SMART_HANDLE";
+  if (!parentType.empty())
+  {
+    os << std::endl
+      << "  class " << stripPrefix(parentType, "Vk") << ";";
+  }
+
+  for (auto const& childType : childrenTypes)
+  {
+    auto handleIt = m_handles.find(childType);
+    assert(handleIt != m_handles.end());
+
+    static const std::string uniqueTypesTemplate = R"(
+  template <typename Dispatch> class UniqueHandleTraits<${type}, Dispatch> { public: using deleter = ${deleterType}${deleterAction}<${deleterParent}${deleterPool}, Dispatch>; };
+  using Unique${type} = UniqueHandle<${type}, DispatchLoaderStatic>;)";
+
+    os << replaceWithMap(uniqueTypesTemplate,
+    {
+      { "type", stripPrefix(childType, "Vk") },
+      { "deleterType", handleIt->second.deletePool.empty() ? "Object" : "Pool" },
+      { "deleterAction", (handleIt->second.deleteCommand.substr(2, 4) == "Free") ? "Free" : "Destroy" },
+      { "deleterParent", parentType.empty() ? "NoParent" : stripPrefix(parentType, "Vk") },
+      { "deleterPool", handleIt->second.deletePool.empty() ? "" : ", " + stripPrefix(handleIt->second.deletePool, "Vk") }
+    });
+  }
+  os << std::endl
+    << "#endif /*VULKAN_HPP_NO_SMART_HANDLE*/" << std::endl;
+}
+
+void VulkanHppGenerator::EnumData::addAlias(std::string const &valueName, std::string const& aliasName, bool bitmask, std::string const& prefix, std::string const& postfix, std::string const& tag)
+{
+  // look for the aliased enum value
+  std::string alias = createEnumValueName(aliasName, prefix, postfix, bitmask, tag);
+  auto valueIt = std::find_if(values.begin(), values.end(), [&alias](std::pair<std::string, std::string> const& value) { return value.second == alias; });
+  assert(valueIt != values.end());
+
+  std::string name = createEnumValueName(valueName, prefix, postfix, bitmask, tag);
+  if (valueIt->second != name)
+  {
+    // only add an alias if it's different from the aliased name
+    aliases.push_back(std::make_pair(valueName, name));
+  }
+}
+
+void VulkanHppGenerator::EnumData::addEnumValue(std::string const &valueName, bool bitmask, std::string const& prefix, std::string const& postfix, std::string const& tag)
+{
+  std::string translatedName = createEnumValueName(valueName, prefix, postfix, bitmask, tag);
+
+  auto it = std::find_if(values.begin(), values.end(), [&translatedName](std::pair<std::string, std::string> const& value) { return value.second == translatedName; });
+  if (it == values.end())
+  {
+    values.push_back(std::make_pair(valueName, translatedName));
+  }
+  else
+  {
+    assert(it->first == valueName);
+  }
+}
+
+std::string VulkanHppGenerator::TypeData::compose() const
+{
+  return prefix + (prefix.empty() ? "" : " ") + stripPrefix(type, "Vk") + postfix;
+}
+
+int main( int argc, char **argv )
+{
+  static const std::string classArrayProxy = R"(
+#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+  template <typename T>
+  class ArrayProxy
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t)
+      : m_count(0)
+      , m_ptr(nullptr)
+    {}
+
+    ArrayProxy(T & ptr)
+      : m_count(1)
+      , m_ptr(&ptr)
+    {}
+
+    ArrayProxy(uint32_t count, T * ptr)
+      : m_count(count)
+      , m_ptr(ptr)
+    {}
+
+    template <size_t N>
+    ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data)
+      : m_count(N)
+      , m_ptr(data.data())
+    {}
+
+    template <size_t N>
+    ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data)
+      : m_count(N)
+      , m_ptr(data.data())
+    {}
+
+    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
+    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data)
+      : m_count(static_cast<uint32_t>(data.size()))
+      , m_ptr(data.data())
+    {}
+
+    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
+    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data)
+      : m_count(static_cast<uint32_t>(data.size()))
+      , m_ptr(data.data())
+    {}
+
+    ArrayProxy(std::initializer_list<T> const& data)
+      : m_count(static_cast<uint32_t>(data.end() - data.begin()))
+      , m_ptr(data.begin())
+    {}
+
+    const T * begin() const
+    {
+      return m_ptr;
+    }
+
+    const T * end() const
+    {
+      return m_ptr + m_count;
+    }
+
+    const T & front() const
+    {
+      VULKAN_HPP_ASSERT(m_count && m_ptr);
+      return *m_ptr;
+    }
+
+    const T & back() const
+    {
+      VULKAN_HPP_ASSERT(m_count && m_ptr);
+      return *(m_ptr + m_count - 1);
+    }
+
+    bool empty() const
+    {
+      return (m_count == 0);
+    }
+
+    uint32_t size() const
+    {
+      return m_count;
+    }
+
+    T * data() const
+    {
+      return m_ptr;
+    }
+
+  private:
+    uint32_t  m_count;
+    T *       m_ptr;
+  };
 #endif
 )";
 
-const std::string exceptionHeader = R"(
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# define noexcept _NOEXCEPT
-#endif
-
-  class ErrorCategoryImpl : public std::error_category
-  {
-    public:
-    virtual const char* name() const noexcept override { return VULKAN_HPP_NAMESPACE_STRING"::Result"; }
-    virtual std::string message(int ev) const override { return to_string(static_cast<Result>(ev)); }
-  };
-
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# undef noexcept
-#endif
-
-  VULKAN_HPP_INLINE const std::error_category& errorCategory()
-  {
-    static ErrorCategoryImpl instance;
-    return instance;
-  }
-
-  VULKAN_HPP_INLINE std::error_code make_error_code(Result e)
-  {
-    return std::error_code(static_cast<int>(e), errorCategory());
-  }
-
-  VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e)
-  {
-    return std::error_condition(static_cast<int>(e), errorCategory());
-  }
-)";
-
-const std::string exceptionClassesHeader = R"(
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# define noexcept _NOEXCEPT
-#endif
-
-  class Error
-  {
-    public:
-    virtual ~Error() = default;
-
-    virtual const char* what() const noexcept = 0;
-  };
-
-  class LogicError : public Error, public std::logic_error
-  {
-    public:
-    explicit LogicError( const std::string& what )
-      : Error(), std::logic_error(what) {}
-    explicit LogicError( char const * what )
-      : Error(), std::logic_error(what) {}
-    virtual ~LogicError() = default;
-
-    virtual const char* what() const noexcept { return std::logic_error::what(); }
-  };
-
-  class SystemError : public Error, public std::system_error
-  {
-    public:
-    SystemError( std::error_code ec )
-      : Error(), std::system_error(ec) {}
-    SystemError( std::error_code ec, std::string const& what )
-      : Error(), std::system_error(ec, what) {}
-    SystemError( std::error_code ec, char const * what )
-      : Error(), std::system_error(ec, what) {}
-    SystemError( int ev, std::error_category const& ecat )
-      : Error(), std::system_error(ev, ecat) {}
-    SystemError( int ev, std::error_category const& ecat, std::string const& what)
-      : Error(), std::system_error(ev, ecat, what) {}
-    SystemError( int ev, std::error_category const& ecat, char const * what)
-      : Error(), std::system_error(ev, ecat, what) {}
-    virtual ~SystemError() = default;
-
-    virtual const char* what() const noexcept { return std::system_error::what(); }
-  };
-
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# undef noexcept
-#endif
-
-)";
-
-const std::string flagsHeader = R"(
+  static const std::string classFlags = R"(
   template <typename FlagBitsType> struct FlagTraits
   {
     enum { allFlags = 0 };
@@ -258,10 +4387,92 @@ const std::string flagsHeader = R"(
   {
     return flags ^ bit;
   }
-
 )";
 
-const std::string optionalClassHeader = R"(
+  static const std::string classObjectDestroy = R"(
+  struct AllocationCallbacks;
+
+  template <typename OwnerType, typename Dispatch>
+  class ObjectDestroy
+  {
+    public:
+      ObjectDestroy( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
+        : m_owner( owner )
+        , m_allocationCallbacks( allocationCallbacks )
+        , m_dispatch( &dispatch )
+      {}
+
+      OwnerType getOwner() const { return m_owner; }
+      Optional<const AllocationCallbacks> getAllocator() const { return m_allocationCallbacks; }
+
+    protected:
+      template <typename T>
+      void destroy(T t)
+      {
+        m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
+      }
+
+    private:
+      OwnerType m_owner;
+      Optional<const AllocationCallbacks> m_allocationCallbacks;
+      Dispatch const* m_dispatch;
+  };
+
+  class NoParent;
+
+  template <typename Dispatch>
+  class ObjectDestroy<NoParent,Dispatch>
+  {
+    public:
+      ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
+        : m_allocationCallbacks( allocationCallbacks )
+        , m_dispatch( &dispatch )
+      {}
+
+      Optional<const AllocationCallbacks> getAllocator() const { return m_allocationCallbacks; }
+
+    protected:
+      template <typename T>
+      void destroy(T t)
+      {
+        t.destroy( m_allocationCallbacks, *m_dispatch );
+      }
+
+    private:
+      Optional<const AllocationCallbacks> m_allocationCallbacks;
+      Dispatch const* m_dispatch;
+  };
+)";
+
+  static const std::string classObjectFree = R"(
+  template <typename OwnerType, typename Dispatch>
+  class ObjectFree
+  {
+    public:
+      ObjectFree( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
+        : m_owner( owner )
+        , m_allocationCallbacks( allocationCallbacks )
+        , m_dispatch( &dispatch )
+      {}
+
+      OwnerType getOwner() const { return m_owner; }
+      Optional<const AllocationCallbacks> getAllocator() const { return m_allocationCallbacks; }
+
+    protected:
+      template <typename T>
+      void destroy(T t)
+      {
+        m_owner.free( t, m_allocationCallbacks, *m_dispatch );
+      }
+
+    private:
+      OwnerType m_owner;
+      Optional<const AllocationCallbacks> m_allocationCallbacks;
+      Dispatch const* m_dispatch;
+  };
+)";
+
+  static const std::string classOptional = R"(
   template <typename RefType>
   class Optional
   {
@@ -279,102 +4490,35 @@ const std::string optionalClassHeader = R"(
   };
 )";
 
-const std::string arrayProxyHeader = R"(
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T>
-  class ArrayProxy
+  static const std::string classPoolFree = R"(
+  template <typename OwnerType, typename PoolType, typename Dispatch>
+  class PoolFree
   {
-  public:
-    VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t)
-      : m_count(0)
-      , m_ptr(nullptr)
-    {}
+    public:
+      PoolFree( OwnerType owner = OwnerType(), PoolType pool = PoolType(), Dispatch const &dispatch = Dispatch() )
+        : m_owner( owner )
+        , m_pool( pool )
+        , m_dispatch( &dispatch )
+      {}
 
-    ArrayProxy(T & ptr)
-      : m_count(1)
-      , m_ptr(&ptr)
-    {}
+      OwnerType getOwner() const { return m_owner; }
+      PoolType getPool() const { return m_pool; }
 
-    ArrayProxy(uint32_t count, T * ptr)
-      : m_count(count)
-      , m_ptr(ptr)
-    {}
+    protected:
+      template <typename T>
+      void destroy(T t)
+      {
+        m_owner.free( m_pool, t, *m_dispatch );
+      }
 
-    template <size_t N>
-    ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data)
-      : m_count(N)
-      , m_ptr(data.data())
-    {}
-
-    template <size_t N>
-    ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data)
-      : m_count(N)
-      , m_ptr(data.data())
-    {}
-
-    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
-    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data)
-      : m_count(static_cast<uint32_t>(data.size()))
-      , m_ptr(data.data())
-    {}
-
-    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
-    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data)
-      : m_count(static_cast<uint32_t>(data.size()))
-      , m_ptr(data.data())
-    {}
-
-    ArrayProxy(std::initializer_list<T> const& data)
-      : m_count(static_cast<uint32_t>(data.end() - data.begin()))
-      , m_ptr(data.begin())
-    {}
-
-    const T * begin() const
-    {
-      return m_ptr;
-    }
-
-    const T * end() const
-    {
-      return m_ptr + m_count;
-    }
-
-    const T & front() const
-    {
-      VULKAN_HPP_ASSERT(m_count && m_ptr);
-      return *m_ptr;
-    }
-
-    const T & back() const
-    {
-      VULKAN_HPP_ASSERT(m_count && m_ptr);
-      return *(m_ptr + m_count - 1);
-    }
-
-    bool empty() const
-    {
-      return (m_count == 0);
-    }
-
-    uint32_t size() const
-    {
-      return m_count;
-    }
-
-    T * data() const
-    {
-      return m_ptr;
-    }
-
-  private:
-    uint32_t  m_count;
-    T *       m_ptr;
+    private:
+      OwnerType m_owner;
+      PoolType m_pool;
+      Dispatch const* m_dispatch;
   };
-#endif
 )";
 
-const std::string structureChainHeader = R"(
-
+  static const std::string classStructureChain = R"(
   template <typename X, typename Y> struct isStructureChainValid { enum { value = false }; };
 
   template <typename P, typename T>
@@ -492,181 +4636,10 @@ const std::string structureChainHeader = R"(
       linkAndCopyElements<TypeList<List, X>, Y, Z...>(yelem, zelem...);
     }
   };
-
 )";
 
-const std::string versionCheckHeader = R"(
-#if !defined(VULKAN_HPP_HAS_UNRESTRICTED_UNIONS)
-# if defined(__clang__)
-#  if __has_feature(cxx_unrestricted_unions)
-#   define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-#  endif
-# elif defined(__GNUC__)
-#  define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
-#  if 40600 <= GCC_VERSION
-#   define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-#  endif
-# elif defined(_MSC_VER)
-#  if 1900 <= _MSC_VER
-#   define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-#  endif
-# endif
-#endif
-)";
-
-const std::string inlineHeader = R"(
-#if !defined(VULKAN_HPP_INLINE)
-# if defined(__clang___)
-#  if __has_attribute(always_inline)
-#   define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
-#  else
-#    define VULKAN_HPP_INLINE inline
-#  endif
-# elif defined(__GNUC__)
-#  define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
-# elif defined(_MSC_VER)
-#  define VULKAN_HPP_INLINE inline
-# else
-#  define VULKAN_HPP_INLINE inline
-# endif
-#endif
-)";
-
-const std::string explicitHeader = R"(
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-# define VULKAN_HPP_TYPESAFE_EXPLICIT
-#else
-# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
-#endif
-)";
-
-const std::string resultValueHeader = R"(
-  template <typename T>
-  struct ResultValue
-  {
-    ResultValue( Result r, T & v )
-      : result( r )
-      , value( v )
-    {}
-
-    ResultValue( Result r, T && v )
-      : result( r )
-      , value( std::move( v ) )
-    {}
-
-    Result  result;
-    T       value;
-
-    operator std::tuple<Result&, T&>() { return std::tuple<Result&, T&>(result, value); }
-  };
-
-  template <typename T>
-  struct ResultValueType
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    typedef ResultValue<T>  type;
-#else
-    typedef T               type;
-#endif
-  };
-
-  template <>
-  struct ResultValueType<void>
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    typedef Result type;
-#else
-    typedef void   type;
-#endif
-  };
-)";
-
-const std::string createResultValueHeader = R"(
-  template <typename T>
-  VULKAN_HPP_INLINE void ignore(T const&) {}
-
-  VULKAN_HPP_INLINE ResultValueType<void>::type createResultValue( Result result, char const * message )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    ignore( message );
-    VULKAN_HPP_ASSERT( result == Result::eSuccess );
-    return result;
-#else
-    if ( result != Result::eSuccess )
-    {
-      throwResultException( result, message );
-    }
-#endif
-  }
-
-  template <typename T>
-  VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValue( Result result, T & data, char const * message )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    ignore( message );
-    VULKAN_HPP_ASSERT( result == Result::eSuccess );
-    return ResultValue<T>( result, std::move( data ) );
-#else
-    if ( result != Result::eSuccess )
-    {
-      throwResultException( result, message );
-    }
-    return std::move( data );
-#endif
-  }
-
-  VULKAN_HPP_INLINE Result createResultValue( Result result, char const * message, std::initializer_list<Result> successCodes )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    ignore( message );
-    VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
-#else
-    if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
-    {
-      throwResultException( result, message );
-    }
-#endif
-    return result;
-  }
-
-  template <typename T>
-  VULKAN_HPP_INLINE ResultValue<T> createResultValue( Result result, T & data, char const * message, std::initializer_list<Result> successCodes )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    ignore( message );
-    VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
-#else
-    if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
-    {
-      throwResultException( result, message );
-    }
-#endif
-    return ResultValue<T>( result, data );
-  }
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename T, typename D>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<T,D>>::type createResultValue( Result result, T & data, char const * message, typename UniqueHandleTraits<T,D>::deleter const& deleter )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    ignore( message );
-    VULKAN_HPP_ASSERT( result == Result::eSuccess );
-    return ResultValue<UniqueHandle<T,D>>( result, UniqueHandle<T,D>(std::move( data ), deleter) );
-#else
-    if ( result != Result::eSuccess )
-    {
-      throwResultException( result, message );
-    }
-    return UniqueHandle<T,D>(data, deleter);
-#endif
-  }
-#endif
-
-)";
-
-const std::string uniqueHandleHeader = R"(
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-
+  static const std::string classUniqueHandle = R"(
+#if !defined(VULKAN_HPP_NO_SMART_HANDLE)
   template <typename Type, typename Dispatch> class UniqueHandleTraits;
 
   template <typename Type, typename Dispatch>
@@ -768,4447 +4741,308 @@ const std::string uniqueHandleHeader = R"(
     lhs.swap( rhs );
   }
 #endif
-
 )";
 
-const std::string deleterClassString = R"(
-  struct AllocationCallbacks;
-
-  template <typename OwnerType, typename Dispatch>
-  class ObjectDestroy
-  {
-    public:
-      ObjectDestroy( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
-        : m_owner( owner )
-        , m_allocationCallbacks( allocationCallbacks )
-        , m_dispatch( &dispatch )
-      {}
-
-      OwnerType getOwner() const { return m_owner; }
-      Optional<const AllocationCallbacks> getAllocator() const { return m_allocationCallbacks; }
-
-    protected:
-      template <typename T>
-      void destroy(T t)
-      {
-        m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
-      }
-
-    private:
-      OwnerType m_owner;
-      Optional<const AllocationCallbacks> m_allocationCallbacks;
-      Dispatch const* m_dispatch;
-  };
-
-  class NoParent;
-
-  template <typename Dispatch>
-  class ObjectDestroy<NoParent,Dispatch>
-  {
-    public:
-      ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
-        : m_allocationCallbacks( allocationCallbacks )
-        , m_dispatch( &dispatch )
-      {}
-
-      Optional<const AllocationCallbacks> getAllocator() const { return m_allocationCallbacks; }
-
-    protected:
-      template <typename T>
-      void destroy(T t)
-      {
-        t.destroy( m_allocationCallbacks, *m_dispatch );
-      }
-
-    private:
-      Optional<const AllocationCallbacks> m_allocationCallbacks;
-      Dispatch const* m_dispatch;
-  };
-
-  template <typename OwnerType, typename Dispatch>
-  class ObjectFree
-  {
-    public:
-      ObjectFree( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
-        : m_owner( owner )
-        , m_allocationCallbacks( allocationCallbacks )
-        , m_dispatch( &dispatch )
-      {}
-
-      OwnerType getOwner() const { return m_owner; }
-      Optional<const AllocationCallbacks> getAllocator() const { return m_allocationCallbacks; }
-
-    protected:
-      template <typename T>
-      void destroy(T t)
-      {
-        m_owner.free( t, m_allocationCallbacks, *m_dispatch );
-      }
-
-    private:
-      OwnerType m_owner;
-      Optional<const AllocationCallbacks> m_allocationCallbacks;
-      Dispatch const* m_dispatch;
-  };
-
-  template <typename OwnerType, typename PoolType, typename Dispatch>
-  class PoolFree
-  {
-    public:
-      PoolFree( OwnerType owner = OwnerType(), PoolType pool = PoolType(), Dispatch const &dispatch = Dispatch() )
-        : m_owner( owner )
-        , m_pool( pool )
-        , m_dispatch( &dispatch )
-      {}
-
-      OwnerType getOwner() const { return m_owner; }
-      PoolType getPool() const { return m_pool; }
-
-    protected:
-      template <typename T>
-      void destroy(T t)
-      {
-        m_owner.free( m_pool, t, *m_dispatch );
-      }
-
-    private:
-      OwnerType m_owner;
-      PoolType m_pool;
-      Dispatch const* m_dispatch;
-  };
-
-)";
-
-
-std::string replaceWithMap(std::string const &input, std::map<std::string, std::string> replacements)
-{
-  // This will match ${someVariable} and contain someVariable in match group 1
-  std::regex re(R"(\$\{([^\}]+)\})");
-  auto it = std::sregex_iterator(input.begin(), input.end(), re);
-  auto end = std::sregex_iterator();
-
-  // No match, just return the original string
-  if (it == end)
-  {
-    return input;
-  }
-
-  std::string result = "";
-  while (it != end)
-  {
-    std::smatch match = *it;
-    auto itReplacement = replacements.find(match[1].str());
-    assert(itReplacement != replacements.end());
-
-    result += match.prefix().str() + ((itReplacement != replacements.end()) ? itReplacement->second : match[0].str());
-    ++it;
-
-    // we've passed the last match. Append the rest of the orignal string
-    if (it == end)
-    {
-      result += match.suffix().str();
-    }
-  }
-  return result;
-}
-
-
-bool beginsWith(std::string const& text, std::string const& prefix);
-void checkAttributes(std::map<std::string, std::string> const& attributes, int line, std::map<std::string, std::set<std::string>> const& required, std::map<std::string, std::set<std::string>> const& optional);
-void checkElements(std::vector<tinyxml2::XMLElement const*> const& elements, std::set<std::string> const& values);
-void checkEmptyElement(tinyxml2::XMLElement const* element);
-void checkOrderedElements(std::vector<tinyxml2::XMLElement const*> const& elements, std::vector<std::string> const& values);
-std::string createEnumValueName(std::string const& name, std::string const& prefix, std::string const& postfix, bool bitmask, std::string const& tag);
-bool endsWith(std::string const& text, std::string const& postfix);
-void enterProtect(std::ostream &os, std::string const& protect);
-std::string extractTag(std::string const& name);
-std::string findTag(std::string const& name, std::set<std::string> const& tags);
-std::string generateEnumNameForFlags(std::string const& name);
-std::map<std::string, std::string> getAttributes(tinyxml2::XMLElement const* element);
-std::vector<tinyxml2::XMLElement const*> getChildElements(tinyxml2::XMLElement const* element);
-bool isErrorEnum(std::string const& enumName);
-void leaveProtect(std::ostream &os, std::string const& protect);
-std::string readArraySize(tinyxml2::XMLNode const* node, std::string& name);
-std::string startUpperCase(std::string const& input);
-std::string startLowerCase(std::string const& input);
-std::string strip(std::string const& value, std::string const& prefix, std::string const& postfix = std::string());
-std::string stripErrorEnumPrefix(std::string const& enumName);
-std::string stripPluralS(std::string const& name);
-std::vector<std::string> tokenize(std::string tokenString, char separator);
-std::string trim(std::string const& input);
-std::string trimEnd(std::string const& input);
-std::string toCamelCase(std::string const& value);
-std::string toUpperCase(std::string const& name);
-void writeFunctionHeaderName(std::ostream & os, std::string const& name, bool singular, bool unique);
-void writeReinterpretCast(std::ostream & os, bool leadingConst, bool vulkanType, std::string const& type, bool trailingPointerToConst);
-void writeStandardOrEnhanced(std::ostream & os, std::string const& standard, std::string const& enhanced);
-void writeTypesafeCheck(std::ostream & os, std::string const& typesafeCheck);
-void writeVersionCheck(std::ostream & os, std::string const& version);
-#if !defined(NDEBUG)
-void skipFeatureRequire(tinyxml2::XMLElement const* element);
-void skipImplicitExternSyncParams(tinyxml2::XMLElement const* element);
-void skipTypeEnum(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes);
-void skipTypeInclude(tinyxml2::XMLElement const* element);
+  static const std::string defines = R"(
+// <tuple> includes <sys/sysmacros.h> through some other header
+// this results in major(x) being resolved to gnu_dev_major(x)
+// which is an expression in a constructor initializer list.
+#if defined(major)
+  #undef major
+#endif
+#if defined(minor)
+  #undef minor
 #endif
 
-bool beginsWith(std::string const& text, std::string const& prefix)
-{
-  return !prefix.empty() && text.substr(0, prefix.length()) == prefix;
-}
-
-// check the validity of an attributes map
-// attributes : the map of name/value pairs of the encountered attributes
-// line       : the line in the xml file where the attributes are listed
-// required   : the required attributes, with a set of allowed values per attribute
-// optional   : the optional attributes, with a set of allowed values per attribute
-void checkAttributes(std::map<std::string, std::string> const& attributes, int line, std::map<std::string, std::set<std::string>> const& required, std::map<std::string, std::set<std::string>> const& optional)
-{
-  std::stringstream ss;
-  ss << line;
-  std::string lineNumber = ss.str();
-
-  // check if all required attributes are included and if there is a set of allowed values, check if the actual value is part of that set
-  for (auto const& r : required)
-  {
-    auto attributesIt = attributes.find(r.first);
-    if (attributesIt == attributes.end())
-    {
-      throw std::runtime_error("Spec error on line " + lineNumber + ": missing attribute <" + r.first + ">");
-    }
-    if (!r.second.empty() && (r.second.find(attributesIt->second) == r.second.end()))
-    {
-      throw std::runtime_error("Spec error on line " + lineNumber + ": unexpected attribute value <" + attributesIt->second + "> in attribute <" + r.first + ">");
-    }
-  }
-  // check if all not required attributes or optional, and if there is a set of allowed values, check if the actual value is part of that set
-  for (auto const& a : attributes)
-  {
-    if (required.find(a.first) == required.end())
-    {
-      auto optionalIt = optional.find(a.first);
-      if (optionalIt == optional.end())
-      {
-        std::cerr << "warning: " << "Unknown attribute " + a.first + " in line " + lineNumber + "!" << std::endl;
-        continue;
-      }
-      if (!optionalIt->second.empty())
-      {
-        std::vector<std::string> values = tokenize(a.second, ',');
-        for (auto const& v : values)
-        {
-          if (optionalIt->second.find(v) == optionalIt->second.end())
-          {
-            throw std::runtime_error("Spec error on line " + lineNumber + ": unexpected attribute value <" + v + "> in attribute <" + a.first + ">");
-          }
-        }
-      }
-    }
-  }
-}
-
-void checkElements(std::vector<tinyxml2::XMLElement const*> const& elements, std::set<std::string> const& values)
-{
-  for (auto e : elements)
-  {
-    if (values.find(e->Value()) == values.end())
-    {
-      std::stringstream ss;
-      ss << e->GetLineNum();
-      std::string lineNumber = ss.str();
-      std::cerr << "warning: Unknown element in spec on line: " << lineNumber << " " << e->Value() << "!" << std::endl;
-    }
-  }
-}
-
-void checkEmptyElement(tinyxml2::XMLElement const* element)
-{
-  checkAttributes(getAttributes(element), element->GetLineNum(), {}, {});
-  checkElements(getChildElements(element), {});
-}
-
-void checkOrderedElements(std::vector<tinyxml2::XMLElement const*> const& elements, std::vector<std::string> const& values)
-{
-  for (size_t i = 0; i < elements.size(); i++)
-  {
-    std::stringstream ss;
-    ss << elements[i]->GetLineNum();
-    std::string lineNumber = ss.str();
-
-    if (values.size() <= i)
-    {
-      throw std::runtime_error("Spec error on line " + lineNumber + ": unexpected surplus element <" + elements[i]->Value() + ">");
-    }
-    if (values[i] != elements[i]->Value())
-    {
-      throw std::runtime_error("Spec error on line " + lineNumber + ": unexpected element <" + elements[i]->Value() + ">, expected <" + values[i] + ">");
-    }
-  }
-}
-
-std::string createEnumValueName(std::string const& name, std::string const& prefix, std::string const& postfix, bool bitmask, std::string const& tag)
-{
-  std::string result = "e" + toCamelCase(strip(name, prefix, postfix));
-  if (bitmask)
-  {
-    size_t pos = result.find("Bit");
-    if (pos != std::string::npos)
-    {
-      result.erase(pos, 3);
-    }
-  }
-  if (!tag.empty() && (result.substr(result.length() - tag.length()) == toCamelCase(tag)))
-  {
-    result = result.substr(0, result.length() - tag.length()) + tag;
-  }
-  return result;
-}
-
-bool endsWith(std::string const& text, std::string const& postfix)
-{
-  return !postfix.empty() && (postfix.length() < text.length()) && (text.substr(text.length() - postfix.length()) == postfix);
-}
-
-void enterProtect(std::ostream &os, std::string const& protect)
-{
-  if (!protect.empty())
-  {
-    os << "#ifdef " << protect << std::endl;
-  }
-}
-
-std::string extractTag(std::string const& name)
-{
-  // the name is supposed to look like: VK_<tag>_<other>
-  size_t start = name.find('_');
-  assert((start != std::string::npos) && (name.substr(0, start) == "VK"));
-  size_t end = name.find('_', start + 1);
-  assert(end != std::string::npos);
-  return name.substr(start + 1, end - start - 1);
-}
-
-std::string findTag(std::string const& name, std::set<std::string> const& tags)
-{
-  // find the tag in a name, return that tag or an empty string
-  auto tagIt = std::find_if(tags.begin(), tags.end(), [&name](std::string const& t)
-  {
-    size_t pos = name.find(t);
-    return (pos != std::string::npos) && (pos == name.length() - t.length());
-  });
-  return tagIt != tags.end() ? *tagIt : "";
-}
-
-std::string generateEnumNameForFlags(std::string const& name)
-{
-  // create a string, where the substring "Flags" is replaced by "FlagBits"
-  std::string generatedName = name;
-  size_t pos = generatedName.rfind("Flags");
-  assert(pos != std::string::npos);
-  generatedName.replace(pos, 5, "FlagBits");
-  return generatedName;
-}
-
-std::map<std::string, std::string> getAttributes(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes;
-  for (auto attribute = element->FirstAttribute(); attribute; attribute = attribute->Next())
-  {
-    assert(attributes.find(attribute->Name()) == attributes.end());
-    attributes[attribute->Name()] = attribute->Value();
-  }
-  return attributes;
-}
-
-std::vector<tinyxml2::XMLElement const*> getChildElements(tinyxml2::XMLElement const* element)
-{
-  std::vector<tinyxml2::XMLElement const*> childElements;
-  for (tinyxml2::XMLElement const* childElement = element->FirstChildElement(); childElement; childElement = childElement->NextSiblingElement())
-  {
-    childElements.push_back(childElement);
-  }
-  return childElements;
-}
-
-bool isErrorEnum(std::string const& enumName)
-{
-  return (enumName.substr(0, 6) == "eError");
-}
-
-void leaveProtect(std::ostream &os, std::string const& protect)
-{
-  if (!protect.empty())
-  {
-    os << "#endif /*" << protect << "*/" << std::endl;
-  }
-}
-
-std::string readArraySize(tinyxml2::XMLNode const* node, std::string& name)
-{
-  std::string arraySize;
-  if (name.back() == ']')
-  {
-    // if the parameter has '[' and ']' in its name, get the stuff inbetween those as the array size and erase that part from the parameter name
-    assert(!node->NextSibling());
-    size_t pos = name.find('[');
-    assert(pos != std::string::npos);
-    arraySize = name.substr(pos + 1, name.length() - 2 - pos);
-    name.erase(pos);
-  }
-  else
-  {
-    // otherwise look for a sibling of this node
-    node = node->NextSibling();
-    if (node && node->ToText())
-    {
-      assert(node->Value());
-      std::string value = trimEnd(node->Value());
-      if (value == "[")
-      {
-        // if this node has '[' as its value, the next node holds the array size, and the node after that needs to hold ']', and there should be no more siblings
-        node = node->NextSibling();
-        assert(node && node->ToElement() && (strcmp(node->Value(), "enum") == 0));
-        arraySize = node->ToElement()->GetText();
-        node = node->NextSibling();
-        assert(node && node->ToText() && (trimEnd(node->Value()) == "]"));
-      }
-      else
-      {
-        // otherwise, the node holds '[' and ']', so get the stuff in between those as the array size
-        assert((value.front() == '[') && (value.back() == ']'));
-        arraySize = value.substr(1, value.length() - 2);
-      }
-      assert(!node->NextSibling() || ((strcmp(node->NextSibling()->Value(), "comment") == 0) && !node->NextSibling()->NextSibling()));
-    }
-  }
-  return arraySize;
-}
-
-std::string startUpperCase(std::string const& input)
-{
-  return static_cast<char>(toupper(input[0])) + input.substr(1);
-}
-
-std::string startLowerCase(std::string const& input)
-{
-  return input.empty() ? "" : static_cast<char>(tolower(input[0])) + input.substr(1);
-}
-
-std::string strip(std::string const& value, std::string const& prefix, std::string const& postfix)
-{
-  std::string strippedValue = value;
-  if (beginsWith(strippedValue, prefix))
-  {
-    strippedValue.erase(0, prefix.length());
-  }
-  if (endsWith(strippedValue, postfix))
-  {
-    strippedValue.erase(strippedValue.length() - postfix.length());
-  }
-  return strippedValue;
-}
-
-std::string stripErrorEnumPrefix(std::string const& enumName)
-{
-  assert(isErrorEnum(enumName));
-  return strip(enumName, "eError");
-}
-
-std::string stripPluralS(std::string const& name)
-{
-  std::string strippedName(name);
-  size_t pos = strippedName.rfind('s');
-  assert(pos != std::string::npos);
-  strippedName.erase(pos, 1);
-  return strippedName;
-}
-
-std::vector<std::string> tokenize(std::string tokenString, char separator)
-{
-  std::vector<std::string> tokens;
-  size_t start = 0, end;
-  do
-  {
-    end = tokenString.find(separator, start);
-    tokens.push_back(tokenString.substr(start, end - start));
-    start = end + 1;
-  } while (end != std::string::npos);
-  return tokens;
-}
-
-std::string trim(std::string const& input)
-{
-  std::string result = input;
-  result.erase(result.begin(), std::find_if(result.begin(), result.end(), [](char c) { return !std::isspace(c); }));
-  result.erase(std::find_if(result.rbegin(), result.rend(), [](char c) { return !std::isspace(c); }).base(), result.end());
-  return result;
-}
-
-std::string trimEnd(std::string const& input)
-{
-  std::string result = input;
-  result.erase(std::find_if(result.rbegin(), result.rend(), [](char c) { return !std::isspace(c); }).base(), result.end());
-  return result;
-}
-
-std::string toCamelCase(std::string const& value)
-{
-  assert(!value.empty() && (isupper(value[0]) || isdigit(value[0])));
-  std::string result;
-  result.reserve(value.size());
-  result.push_back(value[0]);
-  for (size_t i = 1; i < value.size(); i++)
-  {
-    if (value[i] != '_')
-    {
-      if ((value[i - 1] == '_') || isdigit(value[i - 1]))
-      {
-        result.push_back(value[i]);
-      }
-      else
-      {
-        result.push_back(static_cast<char>(tolower(value[i])));
-      }
-    }
-  }
-  return result;
-}
-
-std::string toUpperCase(std::string const& name)
-{
-  std::string convertedName;
-
-  for (size_t i = 0; i<name.length(); i++)
-  {
-    if (isupper(name[i]) && ((i == 0) || islower(name[i - 1]) || isdigit(name[i - 1])))
-    {
-      convertedName.push_back('_');
-    }
-    convertedName.push_back(static_cast<char>(toupper(name[i])));
-  }
-  return convertedName;
-}
-
-void writeFunctionHeaderName(std::ostream & os, std::string const& name, bool singular, bool unique)
-{
-  os << (singular ? stripPluralS(name) : name);
-  if (unique)
-  {
-    os << "Unique";
-  }
-}
-
-void writeReinterpretCast(std::ostream & os, bool leadingConst, bool vulkanType, std::string const& type, bool trailingPointerToConst)
-{
-  os << "reinterpret_cast<";
-  if (leadingConst)
-  {
-    os << "const ";
-  }
-  if (vulkanType)
-  {
-    os << "Vk";
-  }
-  os << type;
-  if (trailingPointerToConst)
-  {
-    os << "* const";
-  }
-  os << "*>";
-}
-
-void writeStandardOrEnhanced(std::ostream & os, std::string const& standard, std::string const& enhanced)
-{
-  if (standard == enhanced)
-  {
-    // standard and enhanced string are equal -> just use one of them and we're done
-    os << standard;
-  }
-  else
-  {
-    // standard and enhanced string differ -> use both, wrapping the enhanced by !VULKAN_HPP_DISABLE_ENHANCED_MODE
-    // determine the argument list of that standard, and compare it with that of the enhanced
-    // if they are equal -> need to have just one; if they differ -> need to have both
-    size_t standardStart = standard.find('(');
-    size_t standardCount = standard.find(')', standardStart) - standardStart;
-    size_t enhancedStart = enhanced.find('(');
-    bool unchangedInterface = (standard.substr(standardStart, standardCount) == enhanced.substr(enhancedStart, standardCount));
-    if (unchangedInterface)
-    {
-      os << "#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE" << std::endl;
-    }
-    os << standard
-      << (unchangedInterface ? "#else" : "#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE") << std::endl
-      << enhanced
-      << "#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/" << std::endl;
-  }
-}
-
-void writeTypesafeCheck(std::ostream & os, std::string const& typesafeCheck)
-{
-  os << "// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default." << std::endl
-    << "// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION" << std::endl
-    << typesafeCheck << std::endl
-    << "# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )" << std::endl
-    << "#  define VULKAN_HPP_TYPESAFE_CONVERSION" << std::endl
-    << "# endif" << std::endl
-    << "#endif" << std::endl;
-}
-
-void writeVersionCheck(std::ostream & os, std::string const& version)
-{
-  os << "static_assert( VK_HEADER_VERSION == " << version << " , \"Wrong VK_HEADER_VERSION!\" );" << std::endl
-    << std::endl;
-}
-
-#if !defined(NDEBUG)
-void skipFeatureRequire(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), {}, { { "name",{} } });
-  checkElements(getChildElements(element), {});
-}
-
-void skipImplicitExternSyncParams(tinyxml2::XMLElement const* element)
-{
-  checkAttributes(getAttributes(element), element->GetLineNum(), {}, {});
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkOrderedElements(children, { "param" });
-  checkEmptyElement(children[0]);
-}
-
-void skipTypeEnum(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes)
-{
-  checkAttributes(attributes, element->GetLineNum(), { { "category",{ "enum" } } }, { { "alias", {} }, { "name",{} } });
-  checkElements(getChildElements(element), {});
-}
-
-void skipTypeInclude(tinyxml2::XMLElement const* element)
-{
-  checkAttributes(getAttributes(element), element->GetLineNum(), { { "category",{ "include" } } }, { { "name",{} } });
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "name" });
-
-  for (auto child : children)
-  {
-    checkEmptyElement(child);
-  }
-}
+// Windows defines MemoryBarrier which is deprecated and collides
+// with the vk::MemoryBarrier struct.
+#if defined(MemoryBarrier)
+  #undef MemoryBarrier
 #endif
 
-template <typename T>
-void VulkanHppGenerator::checkAlias(std::map<std::string, T> const& data, std::string const& name, int line)
-{
-  if (data.find(name) == data.end())
-  {
-    std::stringstream ss;
-    ss << line;
-    std::string lineNumber = ss.str();
-
-    throw std::runtime_error("Spec error on line " + lineNumber + ": missing alias <" + name + ">");
-  }
-}
-
-bool VulkanHppGenerator::containsUnion(std::string const& type, std::map<std::string, StructData> const& structs)
-{
-  // a simple recursive check if a type is or contains a union
-  std::map<std::string, StructData>::const_iterator sit = structs.find(type);
-  bool found = (sit != structs.end());
-  if (found)
-  {
-    found = sit->second.isUnion;
-    for (std::vector<MemberData>::const_iterator mit = sit->second.members.begin(); mit != sit->second.members.end() && !found; ++mit)
-    {
-      found = (mit->type == mit->pureType) && containsUnion(mit->type, structs);
-    }
-  }
-  return found;
-}
-
-void VulkanHppGenerator::checkCorrectness()
-{
-  for (auto command : m_commands)
-  {
-    // check that functions returning a VkResult specify successcodes
-    if ((command.second.unchangedReturnType == "VkResult") && command.second.successCodes.empty())
-    {
-      throw std::runtime_error("Spec error on command Vk" + startUpperCase(command.first) + " : missing successcodes on command returning VkResult!");
-    }
-  }
-}
-
-std::map<std::string, std::string> VulkanHppGenerator::createDefaults()
-{
-  std::map<std::string, std::string> defaultValues;
-  for (auto const& dependency : m_dependencies)
-  {
-    assert(defaultValues.find(dependency.name) == defaultValues.end());
-    switch (dependency.category)
-    {
-    case DependencyData::Category::BITMASK:
-    case DependencyData::Category::HANDLE:
-    case DependencyData::Category::STRUCT:
-    case DependencyData::Category::UNION:        // just call the default constructor for bitmasks, handles, structs, and unions (which are mapped to classes)
-      defaultValues[dependency.name] = dependency.name + "()";
-      break;
-    case DependencyData::Category::COMMAND:    // commands should never be asked for defaults
-      break;
-    case DependencyData::Category::ENUM:
-      assert(m_enums.find(dependency.name) != m_enums.end());
-      setDefault(dependency.name, defaultValues, m_enums.find(dependency.name)->second);
-      break;
-    case DependencyData::Category::FUNC_POINTER: // func_pointers default to nullptr
-      defaultValues[dependency.name] = "nullptr";
-      break;
-    case DependencyData::Category::REQUIRED:     // all required default to "0"
-    case DependencyData::Category::SCALAR:       // all scalars default to "0"
-      defaultValues[dependency.name] = "0";
-      break;
-    default:
-      assert(false && "Unhandled exception category");
-      break;
-    }
-  }
-  return defaultValues;
-}
-
-void VulkanHppGenerator::determineEnhancedReturnType(CommandData & commandData)
-{
-  std::string returnType;
-  // if there is a return parameter of type void or Result, and if it's of type Result it either has just one success code
-  // or two success codes, where the second one is of type eIncomplete and it's a two-step process
-  // -> we can return that parameter
-  if ((commandData.returnParam != INVALID_INDEX)
-    && ((commandData.returnType == "void")
-      || ((commandData.returnType == "Result")
-        && ((commandData.successCodes.size() == 1)
-          || ((commandData.successCodes.size() == 2)
-            && (commandData.successCodes[1] == "eIncomplete")
-            && commandData.twoStep)))))
-  {
-    if (commandData.vectorParams.find(commandData.returnParam) != commandData.vectorParams.end())
-    {
-      // the return parameter is a vector-type parameter
-      if (commandData.params[commandData.returnParam].pureType == "void")
-      {
-        // for a vector of void, we use a vector of uint8_t, instead
-        commandData.enhancedReturnType = "std::vector<uint8_t,Allocator>";
-      }
-      else
-      {
-        // for the other parameters, we use a vector of the pure type
-        commandData.enhancedReturnType = "std::vector<" + commandData.params[commandData.returnParam].pureType + ",Allocator>";
-      }
-    }
-    else
-    {
-      // it's a simple parameter -> get the type and just remove the trailing '*' (originally, it's a pointer)
-      assert(commandData.params[commandData.returnParam].type.back() == '*');
-      assert(commandData.params[commandData.returnParam].type.find("const") == std::string::npos);
-      commandData.enhancedReturnType = commandData.params[commandData.returnParam].type;
-      commandData.enhancedReturnType.pop_back();
-    }
-  }
-  else if ((commandData.returnType == "Result") && (commandData.successCodes.size() == 1))
-  {
-    // an original return of type "Result" with just one successCode is changed to void, errors throw an exception
-    commandData.enhancedReturnType = "void";
-  }
-  else
-  {
-    // the return type just stays the original return type
-    commandData.enhancedReturnType = commandData.returnType;
-  }
-}
-
-void VulkanHppGenerator::determineReducedName(CommandData & commandData)
-{
-  commandData.reducedName = commandData.fullName;
-  std::string searchName = commandData.params[0].pureType;
-  size_t pos = commandData.fullName.find(searchName);
-  if ((pos == std::string::npos) && isupper(searchName[0]))
-  {
-    searchName[0] = static_cast<char>(tolower(searchName[0]));
-    pos = commandData.fullName.find(searchName);
-  }
-  if (pos != std::string::npos)
-  {
-    commandData.reducedName.erase(pos, searchName.length());
-  }
-  else if ((searchName == "commandBuffer") && (commandData.fullName.find("cmd") == 0))
-  {
-    commandData.reducedName.erase(0, 3);
-    pos = 0;
-  }
-  if ((pos == 0) && isupper(commandData.reducedName[0]))
-  {
-    commandData.reducedName[0] = static_cast<char>(tolower(commandData.reducedName[0]));
-  }
-}
-
-void VulkanHppGenerator::determineReturnParam(CommandData & commandData)
-{
-  // for return types of type Result or void, we can replace determine a parameter to return
-  if ((commandData.returnType == "Result") || (commandData.returnType == "void"))
-  {
-    for (size_t i = 0; i < commandData.params.size(); i++)
-    {
-      if ((commandData.params[i].type.find('*') != std::string::npos)
-        && (commandData.params[i].type.find("const") == std::string::npos)
-        && std::find_if(commandData.vectorParams.begin(), commandData.vectorParams.end(), [i](std::pair<size_t, size_t> const& vp) { return vp.second == i; }) == commandData.vectorParams.end())
-      {
-        // it's a non-const pointer and not a vector-size parameter
-        std::map<size_t, size_t>::const_iterator vpit = commandData.vectorParams.find(i);
-        if ((vpit == commandData.vectorParams.end()) || commandData.twoStep || (commandData.vectorParams.size() > 1) || (vpit->second == INVALID_INDEX) || (commandData.params[vpit->second].type.find('*') != std::string::npos))
-        {
-          // it's not a vector parameter, or a two-step process, or there is at least one more vector parameter, or the size argument of this vector parameter is not an argument, or the size argument of this vector parameter is provided by a pointer
-          // -> look for another non-cost pointer argument
-          auto paramIt = std::find_if(commandData.params.begin() + i + 1, commandData.params.end(), [](ParamData const& pd)
-          {
-            return (pd.type.find('*') != std::string::npos) && (pd.type.find("const") == std::string::npos);
-          });
-          // if there is another such argument, we can't decide which one to return -> return INVALID_INDEX
-          // otherwise return the index of the selcted parameter
-          commandData.returnParam = paramIt != commandData.params.end() ? ~0 : i;
-        }
-      }
-    }
-  }
-}
-
-void VulkanHppGenerator::determineSkippedParams(CommandData & commandData)
-{
-  // the size-parameters of vector parameters are not explicitly used in the enhanced API
-  std::for_each(commandData.vectorParams.begin(), commandData.vectorParams.end(), [&commandData](std::pair<size_t, size_t> const& vp) { if (vp.second != INVALID_INDEX) commandData.skippedParams.insert(vp.second); });
-  // and the return parameter is also skipped
-  if (commandData.returnParam != INVALID_INDEX)
-  {
-    commandData.skippedParams.insert(commandData.returnParam);
-  }
-}
-
-void VulkanHppGenerator::determineTemplateParam(CommandData & commandData)
-{
-  for (size_t i = 0; i < commandData.params.size(); i++)
-  {
-    // any vector parameter on the pure type void is templatized in the enhanced API
-    if ((commandData.vectorParams.find(i) != commandData.vectorParams.end()) && (commandData.params[i].pureType == "void"))
-    {
-#if !defined(NDEBUG)
-      for (size_t j = i + 1; j < commandData.params.size(); j++)
-      {
-        assert((commandData.vectorParams.find(j) == commandData.vectorParams.end()) || (commandData.params[j].pureType != "void"));
-      }
-#endif
-      commandData.templateParam = i;
-      break;
-    }
-  }
-  assert((commandData.templateParam == INVALID_INDEX) || (commandData.vectorParams.find(commandData.templateParam) != commandData.vectorParams.end()));
-}
-
-void VulkanHppGenerator::determineVectorParams(CommandData & commandData)
-{
-  // look for the parameters whose len equals the name of an other parameter
-  for (auto it = commandData.params.begin(), begin = it, end = commandData.params.end(); it != end; ++it)
-  {
-    if (!it->len.empty())
-    {
-      auto findLambda = [it](ParamData const& pd) { return pd.name == it->len; };
-      auto findIt = std::find_if(begin, it, findLambda);                        // look for a parameter named as the len of this parameter
-      assert((std::count_if(begin, end, findLambda) == 0) || (findIt < it));    // make sure, there is no other parameter like that
-
-      // add this parameter as a vector parameter, using the len-name parameter as the second value (or INVALID_INDEX if there is nothing like that)
-      commandData.vectorParams.insert(std::make_pair(std::distance(begin, it), findIt < it ? std::distance(begin, findIt) : INVALID_INDEX));
-      assert((commandData.vectorParams[std::distance(begin, it)] != INVALID_INDEX)
-        || (it->len == "null-terminated")
-        || (it->len == "pAllocateInfo::descriptorSetCount")
-        || (it->len == "pAllocateInfo::commandBufferCount"));
-    }
-  }
-}
-
-std::string VulkanHppGenerator::generateCall(CommandData const& commandData, bool firstCall, bool singular)
-{
-  std::ostringstream call;
-  writeCall(call, commandData, firstCall, singular);
-  return call.str();
-}
-
-std::string const& VulkanHppGenerator::getTypesafeCheck() const
-{
-  return m_typesafeCheck;
-}
-
-std::string const& VulkanHppGenerator::getVersion() const
-{
-  return m_version;
-}
-
-std::string const& VulkanHppGenerator::getVulkanLicenseHeader() const
-{
-  return m_vulkanLicenseHeader;
-}
-
-bool VulkanHppGenerator::isSubStruct(std::pair<std::string, StructData> const& nsd, std::string const& name, StructData const& structData)
-{
-  if ((nsd.first != name) && (nsd.second.members.size() < structData.members.size()) && (structData.members[0].name != "sType"))
-  {
-    bool equal = true;
-    for (size_t i = 0; i < nsd.second.members.size() && equal; i++)
-    {
-      equal = (nsd.second.members[i].type == structData.members[i].type) && (nsd.second.members[i].name == structData.members[i].name);
-    }
-    if (equal)
-    {
-      return true;
-    }
-  }
-  return false;
-}
-
-void VulkanHppGenerator::linkCommandToHandle(CommandData & commandData)
-{
-  // first, find the handle named like the type of the first argument
-  // if there is no such handle, look for the unnamed "handle", that gathers all the functions not tied to a specific handle
-  assert(!commandData.params.empty());
-  std::map<std::string, HandleData>::iterator hit = m_handles.find(commandData.params[0].pureType);
-  if (hit == m_handles.end())
-  {
-    hit = m_handles.find("");
-  }
-  assert(hit != m_handles.end());
-
-  // put the command into the handle's list of commands, and store the handle in the commands className
-  hit->second.commands.push_back(commandData.fullName);
-  commandData.className = hit->first;
-
-  // add the dependencies of the command to the dependencies of the handle
-  DependencyData const& commandDD = m_dependencies.back();
-  std::list<DependencyData>::iterator handleDD = std::find_if(m_dependencies.begin(), m_dependencies.end(), [hit](DependencyData const& dd) { return dd.name == hit->first; });
-  assert((handleDD != m_dependencies.end()) || hit->first.empty());
-  if (handleDD != m_dependencies.end())
-  {
-    std::copy_if(commandDD.dependencies.begin(), commandDD.dependencies.end(), std::inserter(handleDD->dependencies, handleDD->dependencies.end()), [hit](std::string const& d) { return d != hit->first; });
-  }
-}
-
-bool VulkanHppGenerator::readCommandParam(tinyxml2::XMLElement const* element, std::set<std::string> & dependencies, std::vector<ParamData> & params)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), {}, { { "externsync",{} },{ "len",{} },{ "noautovalidity",{ "true" } },{ "optional",{ "false", "true" } } });
-  checkElements(getChildElements(element), { "name", "type" });
-
-  ParamData param;
-
-  bool isTwoStep = false;
-  auto lenAttribute = attributes.find("len");
-  if (lenAttribute != attributes.end())
-  {
-    param.len = lenAttribute->second;
-    auto pit = std::find_if(params.begin(), params.end(), [&param](ParamData const& pd) { return param.len == pd.name; });
-    if (pit != params.end())
-    {
-      isTwoStep = (pit->type.find('*') != std::string::npos);
-    }
-  }
-
-  // get the type of the parameter, and put it into the list of dependencies
-  tinyxml2::XMLNode const* child = readCommandParamType(element->FirstChild(), param);
-  dependencies.insert(param.pureType);
-
-  assert(child->ToElement());
-  tinyxml2::XMLElement const* nameElement = child->ToElement();
-  checkEmptyElement(nameElement);
-  param.name = child->ToElement()->GetText();
-
-  param.arraySize = readArraySize(child, param.name);
-
-  auto optionalAttribute = attributes.find("optional");
-  param.optional = (optionalAttribute != attributes.end()) && (optionalAttribute->second == "true");
-
-  params.push_back(param);
-
-  assert(!isTwoStep || (param.type.substr(0, 6) != "const "));
-  return isTwoStep;
-}
-
-tinyxml2::XMLNode const* VulkanHppGenerator::readCommandParamType(tinyxml2::XMLNode const* node, ParamData& param)
-{
-  assert(node);
-  if (node->ToText())
-  {
-    // start type with "const" or "struct", if needed
-    std::string value = trim(node->Value());
-    assert((value == "const") || (value == "struct") || (value == "const struct"));
-    param.type = value + " ";
-    node = node->NextSibling();
-    assert(node);
-  }
-
-  // get the pure type
-  assert(node->ToElement());
-  tinyxml2::XMLElement const* typeElement = node->ToElement();
-  checkEmptyElement(typeElement);
-  std::string type = strip(node->ToElement()->GetText(), "Vk");
-  param.unchangedType = param.type + node->ToElement()->GetText();
-  param.type += type;
-  param.pureType = type;
-
-  // end with "*", "**", or "* const*", if needed
-  node = node->NextSibling();
-  assert(node);
-  if (node->ToText())
-  {
-    std::string value = trimEnd(node->Value());
-    assert((value == "*") || (value == "**") || (value == "* const*"));
-    param.type += value;
-    param.unchangedType += value;
-    node = node->NextSibling();
-  }
-
-  return node;
-}
-
-void VulkanHppGenerator::readCommands(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), {}, { { "comment",{} } });
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "command" });
-
-  for (auto child : children)
-  {
-    readCommandsCommand(child);
-  }
-}
-
-void VulkanHppGenerator::readCommandsCommand(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), {},
-  { { "alias", {} },
-    { "cmdbufferlevel",{ "primary", "secondary" } },
-    { "comment",{} },
-    { "errorcodes",{} },
-    { "name", {} },
-    { "pipeline",{ "compute", "graphics", "transfer" } },
-    { "queues",{ "compute", "graphics", "sparse_binding", "transfer" } },
-    { "renderpass",{ "both", "inside", "outside" } },
-    { "successcodes",{} }
-  });
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-
-  CommandData commandData;
-  auto aliasIt = attributes.find("alias");
-  if (aliasIt != attributes.end())
-  {
-    // for command aliases, create a copy of the aliased command
-    checkAttributes(attributes, element->GetLineNum(), { { "alias",{} },{ "name",{} } }, {});    // re-check on alias type!
-    checkElements(children, {});
-
-    std::string alias = startLowerCase(strip(aliasIt->second, "vk"));
-    checkAlias(m_commands, alias, element->GetLineNum());
-
-    auto commandsIt = m_commands.find(alias);
-    assert(commandsIt != m_commands.end());
-    commandData = commandsIt->second;
-    commandData.fullName = startLowerCase(strip(attributes.find("name")->second, "vk"));
-    commandData.isAlias = true;
-    determineReducedName(commandData);
-    linkCommandToHandle(commandData);
-
-    // add a DependencyData to this name
-    m_dependencies.push_back(DependencyData(DependencyData::Category::COMMAND, commandData.fullName));
-    m_dependencies.back().dependencies.insert(alias);
-  }
-  else
-  {
-    checkElements(children, { "implicitexternsyncparams", "param", "proto" });
-
-    // read the success codes
-    auto successcodesAttribute = attributes.find("successcodes");
-    if (successcodesAttribute != attributes.end())
-    {
-      commandData.successCodes = tokenize(successcodesAttribute->second, ',');
-      for (auto & code : commandData.successCodes)
-      {
-        std::string tag = findTag(code, m_tags);
-        // on each success code: prepend 'e', strip "VK_" and a tag, convert it to camel case, and add the tag again
-        code = std::string("e") + toCamelCase(strip(code, "VK_", tag)) + tag;
-      }
-    }
-
-    for (auto child : children)
-    {
-      std::string value = child->Value();
-      if (value == "param")
-      {
-        commandData.twoStep |= readCommandParam(child, m_dependencies.back().dependencies, commandData.params);
-      }
-      else if (value == "proto")
-      {
-        readCommandProto(child, commandData.returnType, commandData.unchangedReturnType, commandData.fullName);
-      }
-#if !defined(NDEBUG)
-      else
-      {
-        assert(value == "implicitexternsyncparams");
-        skipImplicitExternSyncParams(child);
-      }
-#endif
-    }
-
-    determineReducedName(commandData);
-    linkCommandToHandle(commandData);
-    registerDeleter(commandData);
-    determineVectorParams(commandData);
-    determineReturnParam(commandData);
-    determineTemplateParam(commandData);
-    determineEnhancedReturnType(commandData);
-    determineSkippedParams(commandData);
-  }
-
-  // insert the commandData into the commands-map,
-  assert(m_commands.find(commandData.fullName) == m_commands.end());
-  m_commands.insert(std::make_pair(commandData.fullName, commandData));
-}
-
-void VulkanHppGenerator::readCommandProto(tinyxml2::XMLElement const* element, std::string & returnType, std::string & unchangedReturnType, std::string & fullName)
-{
-  checkAttributes(getAttributes(element), element->GetLineNum(), {}, {});
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkOrderedElements(children, { "type", "name" });
-
-  // get return type and name of the command
-  returnType = strip(children[0]->GetText(), "Vk");
-  unchangedReturnType = children[0]->GetText();
-  fullName = startLowerCase(strip(children[1]->GetText(), "vk"));
-
-  // add an empty DependencyData to this name
-  m_dependencies.push_back(DependencyData(DependencyData::Category::COMMAND, fullName));
-}
-
-void VulkanHppGenerator::readComment(tinyxml2::XMLElement const* element)
-{
-  checkAttributes(getAttributes(element), element->GetLineNum(), {}, {});
-  checkElements(getChildElements(element), {});
-
-  assert(element->GetText());
-  std::string text = element->GetText();
-  if (text.find("\nCopyright") == 0)
-  {
-    assert(m_vulkanLicenseHeader.empty());
-    m_vulkanLicenseHeader = text;
-
-    // erase the part after the Copyright text
-    size_t pos = m_vulkanLicenseHeader.find("\n\n------------------------------------------------------------------------");
-    if (pos != std::string::npos) {
-      m_vulkanLicenseHeader.erase(pos);
-    }
-
-    // replace any '\n' with "\n// "
-    for (pos = m_vulkanLicenseHeader.find('\n'); pos != std::string::npos; pos = m_vulkanLicenseHeader.find('\n', pos + 1))
-    {
-      m_vulkanLicenseHeader.replace(pos, 1, "\n// ");
-    }
-
-    // and add a little message on our own
-    m_vulkanLicenseHeader += "\n\n// This header is generated from the Khronos Vulkan XML API Registry.";
-  }
-
-  m_vulkanLicenseHeader.erase(m_vulkanLicenseHeader.begin(), std::find_if(m_vulkanLicenseHeader.begin(), m_vulkanLicenseHeader.end(), [](char c) { return !std::isspace(c); }));
-}
-
-void VulkanHppGenerator::readDisabledExtensionRequire(tinyxml2::XMLElement const* element)
-{
-  checkAttributes(getAttributes(element), element->GetLineNum(), {}, {});
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "command", "enum", "type" });
-
-  for (auto child : children)
-  {
-    checkElements(getChildElements(child), {});
-
-    std::string value = child->Value();
-    if ((value == "command") || (value == "type"))
-    {
-      std::map<std::string, std::string> attributes = getAttributes(child);
-      checkAttributes(attributes, element->GetLineNum(), { { "name",{} } }, {});
-
-      // disable a command or a type !
-      auto nameAttribute = attributes.find("name");
-      std::string name = (value == "command") ? startLowerCase(strip(nameAttribute->second, "vk")) : strip(nameAttribute->second, "Vk");
-
-      // search this name in the dependencies list and remove it
-      std::list<DependencyData>::const_iterator depIt = std::find_if(m_dependencies.begin(), m_dependencies.end(), [&name](DependencyData const& dd) { return(dd.name == name); });
-      assert(depIt != m_dependencies.end());
-      m_dependencies.erase(depIt);
-
-      // erase it from all dependency sets
-      for (auto & dep : m_dependencies)
-      {
-        dep.dependencies.erase(name);
-      }
-
-      if (value == "command")
-      {
-        // first unlink the command from its class
-        auto commandsIt = m_commands.find(name);
-        assert(commandsIt != m_commands.end());
-        assert(!commandsIt->second.className.empty());
-        auto handlesIt = m_handles.find(commandsIt->second.className);
-        assert(handlesIt != m_handles.end());
-        auto it = std::find(handlesIt->second.commands.begin(), handlesIt->second.commands.end(), name);
-        assert(it != handlesIt->second.commands.end());
-        handlesIt->second.commands.erase(it);
-
-        // then remove the command
-        m_commands.erase(name);
-      }
-      else
-      {
-        // a type simply needs to be removed from the structs and vkTypes sets
-        assert((m_structs.find(name) != m_structs.end()) && (m_vkTypes.find(name) != m_vkTypes.end()));
-        m_structs.erase(name);
-        m_vkTypes.erase(name);
-      }
-    }
-    else
-    {
-      assert(value == "enum");
-      std::map<std::string, std::string> attributes = getAttributes(child);
-      checkAttributes(attributes, child->GetLineNum(), { { "name",{} } }, { { "bitpos", {} }, { "extends",{} },{ "offset",{} },{ "value",{} } });
-    }
-  }
-}
-
-void VulkanHppGenerator::readEnums(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), { { "name",{} } }, { { "comment",{} },{ "type",{ "bitmask", "enum" } } });
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "comment", "enum", "unused" });
-
-  std::string name = strip(attributes.find("name")->second, "Vk");
-
-  if (name == "API Constants")
-  {
-    for (auto child : children)
-    {
-      assert(strcmp(child->Value(), "enum") == 0);
-      readEnumsConstant(child);
-    }
-  }
-  else
-  {
-    checkAttributes(attributes, element->GetLineNum(), { { "name",{} },{ "type",{ "bitmask", "enum" } } }, { { "comment",{} } });   // re-check with type as required
-
-    if (std::find_if(m_dependencies.begin(), m_dependencies.end(), [&name](DependencyData const& dd) { return dd.name == name; }) == m_dependencies.end())
-    {
-      // add an empty DependencyData on this name into the dependencies list
-      m_dependencies.push_back(DependencyData(DependencyData::Category::ENUM, name));
-
-      // add this enum to the set of Vulkan data types
-      assert(m_vkTypes.find(name) == m_vkTypes.end());
-      m_vkTypes.insert(name);
-    }
-
-    // ad an empty EnumData on this name into the enums map
-    std::map<std::string, EnumData>::iterator it = m_enums.insert(std::make_pair(name, EnumData(name))).first;
-    assert(it->second.postfix.empty() && it->second.prefix.empty() && it->second.protect.empty() && it->second.values.empty());
-
-    if (name == "Result")
-    {
-      // special handling for VKResult, as its enums just have VK_ in common
-      it->second.prefix = "VK_";
-    }
-    else
-    {
-      std::string type = attributes.find("type")->second;
-      it->second.bitmask = (type == "bitmask");
-      if (it->second.bitmask)
-      {
-        // for a bitmask enum, start with "VK", cut off the trailing "FlagBits", and convert that name to upper case
-        // end that with "Bit"
-        size_t pos = name.find("FlagBits");
-        assert(pos != std::string::npos);
-        it->second.prefix = "VK" + toUpperCase(name.substr(0, pos)) + "_";
-      }
-      else
-      {
-        // for a non-bitmask enum, start with "VK", and convert the name to upper case
-        it->second.prefix = "VK" + toUpperCase(name) + "_";
-      }
-
-      // if the enum name contains a tag move it from the prefix to the postfix to generate correct enum value names.
-      for (std::set<std::string>::const_iterator tit = m_tags.begin(); tit != m_tags.end(); ++tit)
-      {
-        if ((tit->length() < it->second.prefix.length()) && (it->second.prefix.substr(it->second.prefix.length() - tit->length() - 1) == (*tit + "_")))
-        {
-          it->second.prefix.erase(it->second.prefix.length() - tit->length() - 1);
-          it->second.postfix = "_" + *tit;
-          break;
-        }
-        else if ((tit->length() < it->second.name.length()) && (it->second.name.substr(it->second.name.length() - tit->length()) == *tit))
-        {
-          it->second.postfix = "_" + *tit;
-          break;
-        }
-      }
-    }
-
-    // read the names of the enum values
-    for (auto child : children)
-    {
-      std::string value = child->Value();
-      if (value == "enum")
-      {
-        readEnumsEnum(child, it->second, "");
-      }
-#if !defined(NDEBUG)
-      else
-      {
-        assert((value == "comment") || (value == "unused"));
-      }
-#endif
-    }
-  }
-}
-
-void VulkanHppGenerator::readEnumsEnum(tinyxml2::XMLElement const* element, EnumData & enumData, std::string const& tag)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), { { "name",{} } }, { {"alias", {} }, { "bitpos",{} },{ "comment",{} },{ "value",{} } });
-  assert((attributes.find("alias") != attributes.end()) + (attributes.find("bitpos") != attributes.end()) + (attributes.find("value") != attributes.end()) == 1);
-  checkElements(getChildElements(element), {});
-  auto aliasIt = attributes.find("alias");
-  if (aliasIt != attributes.end())
-  {
-    auto enumIt = std::find_if(enumData.values.begin(), enumData.values.end(), [&aliasIt](EnumValueData const& evd) { return evd.value == aliasIt->second; });
-    assert((enumIt != enumData.values.end()) && enumIt->alias.empty());
-    enumIt->alias = createEnumValueName(attributes.find("name")->second, enumData.prefix, enumData.postfix, enumData.bitmask, tag);
-  }
-  else
-  {
-    enumData.addEnumValue(attributes.find("name")->second, tag, m_nameMap);
-  }
-}
-
-void VulkanHppGenerator::readEnumsConstant(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), { { "name",{} } }, { { "alias", {}}, { "comment",{} }, { "value",{} } });
-  checkElements(getChildElements(element), {});
-  std::string name = attributes.find("name")->second;
-  assert(m_constants.find(name) == m_constants.end());
-
-  auto aliasIt = attributes.find("alias");
-  if (aliasIt != attributes.end())
-  {
-    checkAttributes(attributes, element->GetLineNum(), { {"alias", {}}, { "name", {}} }, {});    // re-check on alias type
-    checkAlias(m_constants, aliasIt->second, element->GetLineNum());
-    m_constants[name] = m_constants.find(aliasIt->second)->second;
-  }
-  else
-  {
-    checkAttributes(attributes, element->GetLineNum(), { { "name",{} }, { "value", {}} }, { {"comment", {} } });    // re-check on non-alias type
-    m_constants[name] = attributes.find("value")->second;
-  }
-}
-
-void VulkanHppGenerator::readExtensionCommand(tinyxml2::XMLElement const* element, std::string const& protect)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), { { "name",{} } }, {});
-  checkElements(getChildElements(element), {});
-
-  // just add the protect string to the CommandData
-  if (!protect.empty())
-  {
-    std::string name = startLowerCase(strip(attributes.find("name")->second, "vk"));
-    std::map<std::string, CommandData>::iterator cit = m_commands.find(name);
-    assert(cit != m_commands.end());
-    cit->second.protect = protect;
-  }
-}
-
-void VulkanHppGenerator::readExtensionEnum(tinyxml2::XMLElement const* element, std::string const& tag)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(),
-  {
-    { "name", {} }
-  },
-  {
-    { "alias", {} },
-    { "bitpos", {} },
-    { "comment", {} },
-    { "dir", { "-" } },
-    { "extends", {} },
-    { "extnumber", {} },
-    { "offset", {} },
-    { "value", {} }
-  });
-  checkElements(getChildElements(element), {});
-
-  // TODO process enums which don't extend existing enums
-  auto extendsIt = attributes.find("extends");
-  if (extendsIt != attributes.end())
-  {
-    std::string extends = strip(extendsIt->second, "Vk");
-    auto enumIt = m_enums.find(extends);
-    assert(enumIt != m_enums.end());
-
-    auto aliasIt = attributes.find("alias");
-    if (aliasIt != attributes.end())
-    {
-      checkAttributes(attributes, element->GetLineNum(), { { "alias", {} }, { "extends", {} }, { "name", {} } }, { { "comment",{} } });
-      std::string alias = createEnumValueName(aliasIt->second, enumIt->second.prefix, enumIt->second.postfix, enumIt->second.bitmask, tag);
-      auto evdIt = std::find_if(enumIt->second.values.begin(), enumIt->second.values.end(), [&alias](EnumValueData const& evd) { return evd.name == alias; });
-      assert(evdIt != enumIt->second.values.end());
-      evdIt->alias = createEnumValueName(attributes.find("name")->second, enumIt->second.prefix, enumIt->second.postfix, enumIt->second.bitmask, tag);
-      if (evdIt->name == evdIt->alias)
-      {
-        // skip alias, that would result in the very same enum name
-        evdIt->alias.clear();
-      }
-    }
-    else
-    {
-      assert((attributes.find("bitpos") != attributes.end()) + (attributes.find("offset") != attributes.end()) + (attributes.find("value") != attributes.end()) == 1);
-      enumIt->second.addEnumValue(attributes.find("name")->second, tag, m_nameMap);
-    }
-  }
-}
-
-void VulkanHppGenerator::readExtensionRequire(tinyxml2::XMLElement const* element, std::string const& protect, std::string const& tag)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), {}, { { "extension",{} },{ "feature",{} } });
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "command", "comment", "enum", "type" });
-
-  for (auto child : children)
-  {
-    std::string value = child->Value();
-
-    if (value == "command")
-    {
-      readExtensionCommand(child, protect);
-    }
-    else if (value == "enum")
-    {
-      readExtensionEnum(child, tag);
-    }
-    else if (value == "type")
-    {
-      readExtensionType(child, protect);
-    }
-#if !defined(NDEBUG)
-    else
-    {
-      assert(value == "comment");
-      checkEmptyElement(child);
-    }
-#endif
-  }
-}
-
-void VulkanHppGenerator::readExtensions(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), { { "comment",{} } }, {});
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "extension" });
-
-  for (auto child : children)
-  {
-    readExtensionsExtension(child);
-  }
-}
-
-void VulkanHppGenerator::readExtensionsExtension(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(),
-  {
-    { "name",{} },
-    { "number",{} },
-    { "supported",{ "disabled", "vulkan" } }
-  },
-  {
-    { "author",{} },
-    { "comment", {} },
-    { "contact",{} },
-    { "deprecatedby", {} },
-    { "obsoletedby", {} },
-    { "platform",{} },
-    { "promotedto", {} },
-    { "provisional", {} },
-    { "requires",{} },
-    { "requiresCore",{} },
-    { "type",{ "device", "instance" } }
-  });
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "require" });
-
-  if (attributes.find("supported")->second == "disabled")
-  {
-    // kick out all the disabled stuff we've read before !!
-    for (tinyxml2::XMLElement const* child = element->FirstChildElement(); child; child = child->NextSiblingElement())
-    {
-      assert(strcmp(child->Value(), "require") == 0);
-      readDisabledExtensionRequire(child);
-    }
-  }
-  else
-  {
-    std::string name = attributes.find("name")->second;
-    std::string tag = extractTag(name);
-    assert(m_tags.find(tag) != m_tags.end());
-
-    std::string protect;
-    auto platformAttribute = attributes.find("platform");
-    if (platformAttribute != attributes.end())
-    {
-      assert(m_platforms.find(platformAttribute->second) != m_platforms.end());
-      protect = m_platforms.find(platformAttribute->second)->second;
-    }
-
-#if !defined(NDEBUG)
-    assert(m_extensions.find(name) == m_extensions.end());
-    ExtensionData & extension = m_extensions.insert(std::make_pair(name, ExtensionData())).first->second;
-    extension.protect = protect;
-    auto requiresAttribute = attributes.find("requires");
-    if (requiresAttribute != attributes.end())
-    {
-      extension.requires = tokenize(requiresAttribute->second, ',');
-    }
+#if !defined(VULKAN_HPP_HAS_UNRESTRICTED_UNIONS)
+# if defined(__clang__)
+#  if __has_feature(cxx_unrestricted_unions)
+#   define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+#  endif
+# elif defined(__GNUC__)
+#  define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#  if 40600 <= GCC_VERSION
+#   define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+#  endif
+# elif defined(_MSC_VER)
+#  if 1900 <= _MSC_VER
+#   define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+#  endif
+# endif
 #endif
 
-    for (auto child : children)
-    {
-      readExtensionRequire(child, protect, tag);
-    }
-  }
-}
-
-void VulkanHppGenerator::readExtensionType(tinyxml2::XMLElement const* element, std::string const& protect)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), { { "name",{} } }, {});
-  checkElements(getChildElements(element), {});
-
-  // add the protect-string to the appropriate type: enum, flag, handle, scalar, or struct
-  if (!protect.empty())
-  {
-    std::string name = strip(attributes.find("name")->second, "Vk");
-    std::map<std::string, BitmaskData>::iterator bitmasksIt = m_bitmasks.find(name);
-    if (bitmasksIt != m_bitmasks.end())
-    {
-      bitmasksIt->second.protect = protect;
-
-      // if the enum of this flags is auto-generated, protect it as well
-      std::string enumName = generateEnumNameForFlags(name);
-      std::map<std::string, EnumData>::iterator enumsIt = m_enums.find(enumName);
-      assert(enumsIt != m_enums.end());
-      if (enumsIt->second.values.empty())
-      {
-        enumsIt->second.protect = protect;
-      }
-    }
-    else
-    {
-      std::map<std::string, EnumData>::iterator eit = m_enums.find(name);
-      if (eit != m_enums.end())
-      {
-        eit->second.protect = protect;
-      }
-      else
-      {
-        std::map<std::string, HandleData>::iterator hait = m_handles.find(name);
-        if (hait != m_handles.end())
-        {
-          hait->second.protect = protect;
-        }
-        else
-        {
-          std::map<std::string, ScalarData>::iterator scit = m_scalars.find(name);
-          if (scit != m_scalars.end())
-          {
-            scit->second.protect = protect;
-          }
-          else
-          {
-            std::map<std::string, StructData>::iterator stit = m_structs.find(name);
-            if (stit != m_structs.end())
-            {
-              stit->second.protect = protect;
-            }
-            else
-            {
-              assert(m_defines.find(name) != m_defines.end());
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-void VulkanHppGenerator::readFeature(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), { { "api",{ "vulkan" } },{ "comment",{} },{ "name",{} },{ "number",{} } }, {});
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "require" });
-
-  for (auto child : children)
-  {
-    readFeatureRequire(child);
-  }
-}
-
-void VulkanHppGenerator::readFeatureRequire(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), {}, { { "comment",{} } });
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "command", "comment", "enum", "type" });
-
-  for (auto child : children)
-  {
-    std::string value = child->Value();
-    if (value == "enum")
-    {
-      readFeatureRequireEnum(child);
-    }
-#if !defined(NDEBUG)
-    else
-    {
-      assert((value == "command") || (value == "comment") || (value == "type"));
-      skipFeatureRequire(child);
-    }
+#if !defined(VULKAN_HPP_INLINE)
+# if defined(__clang___)
+#  if __has_attribute(always_inline)
+#   define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
+#  else
+#    define VULKAN_HPP_INLINE inline
+#  endif
+# elif defined(__GNUC__)
+#  define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
+# elif defined(_MSC_VER)
+#  define VULKAN_HPP_INLINE inline
+# else
+#  define VULKAN_HPP_INLINE inline
+# endif
 #endif
-  }
-}
-
-void VulkanHppGenerator::readFeatureRequireEnum(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(),
-  {
-    { "name",{} }
-  },
-  {
-    { "bitpos",{} },
-    { "comment",{} },
-    { "dir", { "-" } },
-    { "extends",{} },
-    { "extnumber", {} },
-    { "offset", {} },
-    { "value",{} }
-  });
-  checkElements(getChildElements(element), {});
-
-  auto extendsAttribute = attributes.find("extends");
-  if (extendsAttribute != attributes.end())
-  {
-    assert(strncmp(extendsAttribute->second.c_str(), "Vk", 2) == 0);
-    std::string extends = strip(extendsAttribute->second, "Vk");
-    auto enumIt = m_enums.find(extends);
-    assert(enumIt != m_enums.end());
-    enumIt->second.addEnumValue(attributes.find("name")->second, "", m_nameMap);
-  }
-}
-
-void VulkanHppGenerator::readPlatform(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), { { "name",{} },{ "protect",{} },{ "comment",{} } }, {});
-  checkElements(getChildElements(element), {});
-
-  std::string name, protect;
-  for (auto const& attribute : attributes)
-  {
-    std::string value = attribute.first;
-    if (value == "name")
-    {
-      name = attribute.second;
-    }
-    else if (value == "protect")
-    {
-      protect = attribute.second;
-    }
-  }
-  assert(!name.empty() && !protect.empty());
-  assert(m_platforms.find(name) == m_platforms.end());
-  m_platforms[name] = protect;
-}
-
-void VulkanHppGenerator::readPlatforms(tinyxml2::XMLElement const* element)
-{
-  checkAttributes(getAttributes(element), element->GetLineNum(), { { "comment",{} } }, {});
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "platform" });
-
-  for (auto child : children)
-  {
-    readPlatform(child);
-  }
-}
-
-void VulkanHppGenerator::readTags(tinyxml2::XMLElement const* element)
-{
-  checkAttributes(getAttributes(element), element->GetLineNum(), { { "comment",{} } }, {});
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "tag" });
-
-  for (auto child : children)
-  {
-    readTag(child);
-  }
-}
-
-void VulkanHppGenerator::readTag(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), { { "author",{} },{ "contact",{} },{ "name",{} } }, {});
-  checkElements(getChildElements(element), {});
-
-  for (auto const& attribute : attributes)
-  {
-    std::string name = attribute.first;
-    if (name == "name")
-    {
-      std::string value = attribute.second;
-      m_tags.insert(value);
-    }
-    else
-    {
-      assert((name == "author") || (name == "contact"));
-    }
-  }
-}
-
-void VulkanHppGenerator::readType(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-
-  auto categoryIt = attributes.find("category");
-  if (categoryIt != attributes.end())
-  {
-    if (categoryIt->second == "basetype")
-    {
-      readTypeBasetype(element, attributes);
-    }
-    else if (categoryIt->second == "bitmask")
-    {
-      readTypeBitmask(element, attributes);
-    }
-    else if (categoryIt->second == "define")
-    {
-      readTypeDefine(element, attributes);
-    }
-    else if (categoryIt->second == "funcpointer")
-    {
-      readTypeFuncpointer(element, attributes);
-    }
-    else if (categoryIt->second == "handle")
-    {
-      readTypeHandle(element, attributes);
-    }
-    else if (categoryIt->second == "struct")
-    {
-      readTypeStruct(element, false, attributes);
-    }
-    else if (categoryIt->second == "union")
-    {
-      readTypeStruct(element, true, attributes);
-    }
-#if !defined(NDEBUG)
-    else if (categoryIt->second == "enum")
-    {
-      skipTypeEnum(element, attributes);
-    }
-    else if (categoryIt->second == "include")
-    {
-      skipTypeInclude(element);
-    }
-    else
-#else
-    else if ((categoryIt->second != "enum") && (categoryIt->second != "include"))
-#endif
-    {
-      std::stringstream ss;
-      ss << element->GetLineNum();
-      std::string lineNumber = ss.str();
-
-      throw std::runtime_error("Spec error on line " + lineNumber + ": unknown category <" + categoryIt->second + ">");
-    }
-  }
-  else
-  {
-    assert(attributes.find("name") != attributes.end());
-    readTypeName(element, attributes);
-  }
-}
-
-void VulkanHppGenerator::readTypeBasetype(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes)
-{
-  checkAttributes(attributes, element->GetLineNum(), { { "category",{ "basetype" } } }, {});
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkOrderedElements(children, { "type", "name" });
-  checkEmptyElement(children[0]);
-  checkEmptyElement(children[1]);
-
-  std::string type = children[0]->GetText();
-  assert((type == "uint32_t") || (type == "uint64_t"));
-
-  std::string name = strip(children[1]->GetText(), "Vk");
-
-  // skip "Flags",
-  if (name != "Flags")
-  {
-    m_dependencies.push_back(DependencyData(DependencyData::Category::SCALAR, name));
-    m_dependencies.back().dependencies.insert(type);
-  }
-  else
-  {
-    assert(type == "uint32_t");
-  }
-}
-
-void VulkanHppGenerator::readTypeBitmask(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes)
-{
-  checkAttributes(attributes, element->GetLineNum(), { { "category", { "bitmask" } } }, { { "alias", {} }, { "name", {}}, { "requires", {} } });
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-
-  auto aliasIt = attributes.find("alias");
-  if (aliasIt != attributes.end())
-  {
-    checkAttributes(attributes, element->GetLineNum(), { { "alias", {} }, { "category", {"bitmask"} }, { "name", {} } }, {});   // re-check on alias type!
-    checkElements(children, {});
-
-    std::string alias = strip(aliasIt->second, "Vk");
-    checkAlias(m_bitmasks, alias, element->GetLineNum());
-
-    std::string name = strip(attributes.find("name")->second, "Vk");
-
-    auto bitmasksIt = m_bitmasks.find(alias);
-    assert((bitmasksIt != m_bitmasks.end()) && bitmasksIt->second.alias.empty());
-    bitmasksIt->second.alias = name;
-  }
-  else
-  {
-    checkOrderedElements(children, { "type", "name" });
-    checkEmptyElement(children[0]);
-    checkEmptyElement(children[1]);
-
-    assert(strcmp(children[0]->GetText(), "VkFlags") == 0);
-
-    std::string name = strip(children[1]->GetText(), "Vk");
-
-    std::string requires;
-    auto requiresIt = attributes.find("requires");
-    if (requiresIt != attributes.end())
-    {
-      requires = strip(requiresIt->second, "Vk");
-    }
-    else
-    {
-      // Generate FlagBits name, add a DependencyData for that name, and add it to the list of enums and vulkan types
-      requires = generateEnumNameForFlags(name);
-      assert(std::find_if(m_dependencies.begin(), m_dependencies.end(), [&requires](DependencyData const& dd) { return dd.name == requires; }) == m_dependencies.end());
-      m_dependencies.push_back(DependencyData(DependencyData::Category::ENUM, requires));
-      assert(m_enums.find(requires) == m_enums.end());
-      m_enums.insert(std::make_pair(requires, EnumData(requires, true)));
-      assert(m_vkTypes.find(requires) == m_vkTypes.end());
-      m_vkTypes.insert(requires);
-    }
-
-    // add a DependencyData for the bitmask name, with the required type as its first dependency
-    m_dependencies.push_back(DependencyData(DependencyData::Category::BITMASK, name));
-    m_dependencies.back().dependencies.insert(requires);
-
-    m_bitmasks.insert(std::make_pair(name, BitmaskData()));
-
-    assert(m_vkTypes.find(name) == m_vkTypes.end());
-    m_vkTypes.insert(name);
-  }
-}
-
-void VulkanHppGenerator::readTypeDefine(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes)
-{
-  checkAttributes(attributes, element->GetLineNum(), { { "category",{ "define" } } }, { { "name",{} } });
-
-  auto nameIt = attributes.find("name");
-  if (nameIt != attributes.end())
-  {
-    assert(!element->FirstChildElement());
-    assert(nameIt->second == "VK_DEFINE_NON_DISPATCHABLE_HANDLE");
-
-    // filter out the check for the different types of VK_DEFINE_NON_DISPATCHABLE_HANDLE
-    std::string text = element->LastChild()->ToText()->Value();
-    size_t start = text.find("#if defined(__LP64__)");
-    size_t end = text.find_first_of("\r\n", start + 1);
-    m_typesafeCheck = text.substr(start, end - start);
-  }
-  else if (element->GetText() && (trim(element->GetText()) == "struct"))
-  {
-    tinyxml2::XMLElement const* child = element->FirstChildElement();
-    assert(child && (strcmp(child->Value(), "name") == 0) && child->GetText());
-    m_defines.insert(child->GetText());
-    m_dependencies.push_back(DependencyData(DependencyData::Category::REQUIRED, child->GetText()));
-  }
-  else
-  {
-    tinyxml2::XMLElement const* child = element->FirstChildElement();
-    assert(child && !child->FirstAttribute() && (strcmp(child->Value(), "name") == 0) && child->GetText());
-    std::string text = trim(child->GetText());
-    if (text == "VK_HEADER_VERSION")
-    {
-      m_version = trimEnd(element->LastChild()->ToText()->Value());
-    }
-    // ignore all the other defines
-    assert(!child->NextSiblingElement() || (child->NextSiblingElement() && !child->NextSiblingElement()->FirstAttribute() && (strcmp(child->NextSiblingElement()->Value(), "type") == 0) && !child->NextSiblingElement()->NextSiblingElement()));
-  }
-}
-
-void VulkanHppGenerator::readTypeFuncpointer(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes)
-{
-  checkAttributes(attributes, element->GetLineNum(), { { "category",{ "funcpointer" } } }, { { "requires",{} } });
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "name", "type" });
-  assert(!children.empty());
-  checkEmptyElement(children[0]);
-
-  assert((strcmp(children[0]->Value(), "name") == 0) && children[0]->GetText());
-  m_dependencies.push_back(DependencyData(DependencyData::Category::FUNC_POINTER, children[0]->GetText()));
-
-#if !defined(NDEBUG)
-  for (size_t i = 1; i < children.size(); i++)
-  {
-    checkEmptyElement(children[i]);
-  }
-#endif
-}
-
-void VulkanHppGenerator::readTypeHandle(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes)
-{
-  checkAttributes(attributes, element->GetLineNum(), { { "category",{ "handle" } } }, { { "alias",{} }, { "name",{} }, { "parent",{} } });
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-
-  auto aliasIt = attributes.find("alias");
-  if (aliasIt != attributes.end())
-  {
-    checkAttributes(attributes, element->GetLineNum(), { { "alias",{} },{ "category",{ "handle" } },{ "name",{} } }, {});   // re-check on alias type!
-    checkElements(children, {});
-
-    std::string alias = strip(aliasIt->second, "Vk");
-    checkAlias(m_handles, alias, element->GetLineNum());
-
-    std::string name = strip(attributes.find("name")->second, "Vk");
-
-    auto handlesIt = m_handles.find(alias);
-    assert((handlesIt != m_handles.end()) && handlesIt->second.alias.empty());
-    handlesIt->second.alias = name;
-  }
-  else
-  {
-    checkOrderedElements(children, { "type", "name" });
-    checkEmptyElement(children[0]);
-    checkEmptyElement(children[1]);
-
-#if !defined(NDEBUG)
-    std::string type = children[0]->GetText();
-    assert((type.find("VK_DEFINE_HANDLE") == 0) || (type.find("VK_DEFINE_NON_DISPATCHABLE_HANDLE") == 0));
-#endif
-
-    std::string name = strip(children[1]->GetText(), "Vk");
-
-    m_dependencies.push_back(DependencyData(DependencyData::Category::HANDLE, name));
-
-    assert(m_vkTypes.find(name) == m_vkTypes.end());
-    m_vkTypes.insert(name);
-    assert(m_handles.find(name) == m_handles.end());
-    m_handles.insert(std::make_pair(name, HandleData()));
-  }
-}
-
-void VulkanHppGenerator::readTypeName(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes)
-{
-  checkAttributes(attributes, element->GetLineNum(), { { "name",{} } }, { { "requires",{} } });
-  checkElements(getChildElements(element), {});
-
-  auto nameIt = attributes.find("name");
-  assert(nameIt != attributes.end());
-  m_dependencies.push_back(DependencyData(DependencyData::Category::REQUIRED, nameIt->second));
-}
-
-void VulkanHppGenerator::readTypes(tinyxml2::XMLElement const* element)
-{
-  checkAttributes(getAttributes(element), element->GetLineNum(), { { "comment",{} } }, {});
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "comment", "type" });
-
-  for (auto child : children)
-  {
-    std::string value = child->Value();
-    if (value == "type")
-    {
-      readType(child);
-    }
-#if !defined(NDEBUG)
-    else
-    {
-      assert(value == "comment");
-      checkEmptyElement(child);
-    }
-#endif
-  }
-}
-
-void VulkanHppGenerator::readTypeStruct(tinyxml2::XMLElement const* element, bool isUnion, std::map<std::string, std::string> const& attributes)
-{
-  checkAttributes(attributes, element->GetLineNum(),
-  {
-    { "category",{ isUnion ? "union" : "struct" } },
-    { "name",{} }
-  },
-  {
-    { "alias", {} },
-    { "comment",{} },
-    { "returnedonly",{ "true" } },
-    { "structextends",{} }
-  });
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "comment", "member" });
-
-  std::string name = strip(attributes.find("name")->second, "Vk");
-
-  auto aliasIt = attributes.find("alias");
-  if (aliasIt != attributes.end())
-  {
-    checkAttributes(attributes, element->GetLineNum(), { { "alias", {}}, {"category", {"struct"}}, { "name", {}} }, {});    // re-check on alias type!
-
-    std::string alias = strip(aliasIt->second, "Vk");
-    checkAlias(m_structs, alias, element->GetLineNum());
-
-    auto structsIt = m_structs.find(alias);
-    assert((structsIt != m_structs.end()) && structsIt->second.alias.empty());
-    structsIt->second.alias = name;
-  }
-  else
-  {
-    m_dependencies.push_back(DependencyData(isUnion ? DependencyData::Category::UNION : DependencyData::Category::STRUCT, name));
-
-    assert(m_structs.find(name) == m_structs.end());
-    std::map<std::string, StructData>::iterator it = m_structs.insert(std::make_pair(name, StructData())).first;
-    it->second.returnedOnly = (attributes.find("returnedonly") != attributes.end());
-    it->second.isUnion = isUnion;
-
-    auto attributesIt = attributes.find("structextends");
-    if (attributesIt != attributes.end())
-    {
-      std::vector<std::string> structExtends = tokenize(attributesIt->second, ',');
-      for (auto const& s : structExtends)
-      {
-        assert(s.substr(0, 2) == "Vk");
-        std::string strippedName = s.substr(2);
-        it->second.structExtends.push_back(strippedName);
-        m_extendedStructs.insert(strippedName);
-      }
-      assert(!it->second.structExtends.empty());
-    }
-
-    for (auto child : children)
-    {
-      assert(child->Value());
-      std::string value = child->Value();
-      if (value == "member")
-      {
-        readTypeStructMember(child, it->second);
-      }
-#if !defined(NDEBUG)
-      else
-      {
-        assert(value == "comment");
-        checkEmptyElement(child);
-      }
-#endif
-    }
-
-    for (auto const& s : m_structs)
-    {
-      if (isSubStruct(s, name, it->second))
-      {
-        it->second.subStruct = s.first;
-        break;    // just take the very first candidate as a subStruct, skip any possible others!
-      }
-    }
-  }
-
-  assert(m_vkTypes.find(name) == m_vkTypes.end());
-  m_vkTypes.insert(name);
-}
-
-void VulkanHppGenerator::readTypeStructMember(tinyxml2::XMLElement const* element, StructData & structData)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), {},
-  {
-    { "altlen",{} },
-    { "externsync",{ "true" } },
-    { "len",{} },
-    { "noautovalidity",{ "true" } },
-    { "optional",{ "false", "true" } },
-    { "values",{} }
-  });
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "comment", "enum", "name", "type" });
-  for (auto child : children)
-  {
-    checkEmptyElement(child);
-  }
-
-  structData.members.push_back(MemberData());
-  MemberData & member = structData.members.back();
-
-  auto valuesAttribute = attributes.find("values");
-  if (valuesAttribute != attributes.end())
-  {
-    member.values = valuesAttribute->second;
-  }
-
-  tinyxml2::XMLNode const* child = element->FirstChild();
-  assert(child);
-  if (child->ToText())
-  {
-    std::string value = trim(child->Value());
-    assert((value == "const") || (value == "struct") || value == "const struct");
-    member.type = value + " ";
-    child = child->NextSibling();
-    assert(child);
-  }
-
-  assert(child->ToElement());
-  tinyxml2::XMLElement const* typeElement = child->ToElement();
-  assert((strcmp(typeElement->Value(), "type") == 0) && typeElement->GetText());
-  member.pureType = strip(typeElement->GetText(), "Vk");
-  member.type += member.pureType;
-
-  child = typeElement->NextSibling();
-  assert(child);
-  if (child->ToText())
-  {
-    std::string value = trimEnd(child->Value());
-    assert((value == "*") || (value == "**") || (value == "* const*"));
-    member.type += value;
-    child = child->NextSibling();
-  }
-
-  m_dependencies.back().dependencies.insert(member.pureType);
-
-  assert(child->ToElement());
-  tinyxml2::XMLElement const* nameElement = child->ToElement();
-  assert((strcmp(nameElement->Value(), "name") == 0) && nameElement->GetText());
-  member.name = nameElement->GetText();
-
-  member.arraySize = readArraySize(nameElement, member.name);
-}
-
-void VulkanHppGenerator::registerDeleter(CommandData const& commandData)
-{
-  if ((commandData.fullName.substr(0, 7) == "destroy") || (commandData.fullName.substr(0, 4) == "free"))
-  {
-    std::string key;
-    size_t valueIndex;
-    switch (commandData.params.size())
-    {
-    case 2:
-    case 3:
-      assert(commandData.params.back().pureType == "AllocationCallbacks");
-      key = (commandData.params.size() == 2) ? "" : commandData.params[0].pureType;
-      valueIndex = commandData.params.size() - 2;
-      break;
-    case 4:
-      key = commandData.params[0].pureType;
-      valueIndex = 3;
-      assert(m_deleters.find(commandData.params[valueIndex].pureType) == m_deleters.end());
-      m_deleters[commandData.params[valueIndex].pureType].pool = commandData.params[1].pureType;
-      break;
-    default:
-      assert(false);
-      valueIndex = 0;
-    }
-    assert(m_deleterTypes[key].find(commandData.params[valueIndex].pureType) == m_deleterTypes[key].end());
-    m_deleterTypes[key].insert(commandData.params[valueIndex].pureType);
-    m_deleters[commandData.params[valueIndex].pureType].call = commandData.reducedName;
-  }
-}
-
-void VulkanHppGenerator::setDefault(std::string const& name, std::map<std::string, std::string> & defaultValues, EnumData const& enumData)
-{
-  defaultValues[name] = name + (enumData.values.empty() ? "()" : ("::" + enumData.values.front().name));
-}
-
-void VulkanHppGenerator::sortDependencies()
-{
-  std::set<std::string> listedTypes = { "VkFlags" };
-  std::list<DependencyData> sortedDependencies;
-
-  while (!m_dependencies.empty())
-  {
-    bool found = false;
-    for (std::list<DependencyData>::iterator it = m_dependencies.begin(); it != m_dependencies.end(); ++it)
-    {
-      // check if all dependencies of it are already listed
-      if (std::find_if(it->dependencies.begin(), it->dependencies.end(), [&listedTypes](std::string const& d) { return listedTypes.find(d) == listedTypes.end(); }) == it->dependencies.end())
-      {
-        // add it to the end of the sorted list and the set of listed types, remove it from the list of dependencies to handle and start over with the next dependency
-        sortedDependencies.push_back(*it);
-        listedTypes.insert(it->name);
-
-        // if it is a struct, add any alias of it to the list of encountered types
-        if (it->category == DependencyData::Category::STRUCT)
-        {
-          std::map<std::string, StructData>::const_iterator sit = m_structs.find(it->name);
-          assert(sit != m_structs.end());
-          if (!sit->second.alias.empty())
-          {
-            assert(listedTypes.find(sit->second.alias) == listedTypes.end());
-            listedTypes.insert(sit->second.alias);
-          }
-        }
-        m_dependencies.erase(it);
-        found = true;
-        break;
-      }
-    }
-    if (!found)
-    {
-      // at least one dependency of it is not yet listed -> resolve direct circular dependencies
-      for (std::list<DependencyData>::iterator it = m_dependencies.begin(); !found && it != m_dependencies.end(); ++it)
-      {
-        for (std::set<std::string>::const_iterator dit = it->dependencies.begin(); dit != it->dependencies.end(); ++dit)
-        {
-          std::list<DependencyData>::const_iterator depIt = std::find_if(m_dependencies.begin(), m_dependencies.end(), [&dit](DependencyData const& dd) { return(dd.name == *dit); });
-          if (depIt != m_dependencies.end())
-          {
-            if (depIt->dependencies.find(it->name) != depIt->dependencies.end())
-            {
-              // we only have two cases, for now!
-              assert((depIt->category == DependencyData::Category::STRUCT) && ((it->category == DependencyData::Category::HANDLE) || (it->category == DependencyData::Category::STRUCT)));
-              it->forwardDependencies.insert(*dit);
-              it->dependencies.erase(*dit);
-              found = true;
-              break;
-            }
-          }
-#if !defined(NDEBUG)
-          else
-          {
-            // here, only already sorted dependencies should occur, or structs that are aliased and sorted
-            std::list<DependencyData>::const_iterator sdit = std::find_if(sortedDependencies.begin(), sortedDependencies.end(), [&dit](DependencyData const& dd) { return(dd.name == *dit); });
-            if (sdit == sortedDependencies.end())
-            {
-              std::map<std::string, StructData>::const_iterator sit = std::find_if(m_structs.begin(), m_structs.end(), [&dit](std::pair<std::string, StructData> const& sd) { return sd.second.alias == *dit; });
-              assert(sit != m_structs.end());
-              assert(std::find_if(sortedDependencies.begin(), sortedDependencies.end(), [sit](DependencyData const& dd) { return dd.name == sit->first; }) != sortedDependencies.end());
-            }
-          }
-#endif
-        }
-      }
-    }
-    assert(found);
-  }
-
-  m_dependencies.swap(sortedDependencies);
-}
-
-void VulkanHppGenerator::writeArguments(std::ostream & os, CommandData const& commandData, bool firstCall, bool singular, size_t from, size_t to)
-{
-  assert(from <= to);
-
-  // get the parameter indices of the counter for vector parameters
-  std::map<size_t, size_t> countIndices;
-  for (std::map<size_t, size_t>::const_iterator it = commandData.vectorParams.begin(); it != commandData.vectorParams.end(); ++it)
-  {
-    countIndices.insert(std::make_pair(it->second, it->first));
-  }
-
-  bool encounteredArgument = false;
-  for (size_t i = from; i < to; i++)
-  {
-    if (encounteredArgument)
-    {
-      os << ", ";
-    }
-
-    std::map<size_t, size_t>::const_iterator it = countIndices.find(i);
-    if (it != countIndices.end())
-    {
-      writeCallCountParameter(os, commandData, singular, it);
-    }
-    else if ((it = commandData.vectorParams.find(i)) != commandData.vectorParams.end())
-    {
-      writeCallVectorParameter(os, commandData, firstCall, singular, it);
-    }
-    else if (m_vkTypes.find(commandData.params[i].pureType) != m_vkTypes.end())
-    {
-      writeCallVulkanTypeParameter(os, commandData.params[i]);
-    }
-    else
-    {
-      writeCallPlainTypeParameter(os, commandData.params[i]);
-    }
-    encounteredArgument = true;
-  }
-}
-
-void VulkanHppGenerator::writeBitmaskToString(std::ostream & os, std::string const& bitmaskName, EnumData const &enumData)
-{
-  // the helper functions to make strings out of flag values
-  enterProtect(os, enumData.protect);
-  os << "  VULKAN_HPP_INLINE std::string to_string(" << bitmaskName << (enumData.values.empty() ? ")" : " value)") << std::endl
-    << "  {" << std::endl;
-  if (enumData.values.empty())
-  {
-    // no flags values in this enum -> return "{}"
-    os << "    return \"{}\";" << std::endl;
-  }
-  else
-  {
-    os << "    if (!value) return \"{}\";" << std::endl
-      << "    std::string result;" << std::endl;
-
-    // 'or' together all the bits in the value
-    for (auto valuesIt = enumData.values.begin(); valuesIt != enumData.values.end(); ++valuesIt)
-    {
-      os << "    if (value & " << enumData.name << "::" << valuesIt->name << ") result += \"" << valuesIt->name.substr(1) << " | \";" << std::endl;
-    }
-    // cut off the last three characters from the result (being " | ")
-    os << "    return \"{\" + result.substr(0, result.size() - 3) + \"}\";" << std::endl;
-  }
-  os << "  }" << std::endl;
-  leaveProtect(os, enumData.protect);
-  os << std::endl;
-}
-
-void VulkanHppGenerator::writeCall(std::ostream & os, CommandData const& commandData, bool firstCall, bool singular)
-{
-  // the original function call
-  os << "d.vk" << startUpperCase(commandData.fullName) << "( ";
-
-  if (!commandData.className.empty())
-  {
-    // if it's member of a class -> the first argument is the member variable, starting with "m_"
-    assert(commandData.className == commandData.params[0].type);
-    os << "m_" << startLowerCase(commandData.className);
-    if (1 < commandData.params.size())
-    {
-      os << ", ";
-    }
-  }
-
-  writeArguments(os, commandData, firstCall, singular, commandData.className.empty() ? 0 : 1, commandData.params.size());
-  os << " )";
-}
-
-void VulkanHppGenerator::writeCallCountParameter(std::ostream & os, CommandData const& commandData, bool singular, std::map<size_t, size_t>::const_iterator it)
-{
-  // this parameter is a count parameter for a vector parameter
-  if ((commandData.returnParam == it->second) && commandData.twoStep)
-  {
-    // the corresponding vector parameter is the return parameter and it's a two-step algorithm
-    // -> use the pointer to a local variable named like the counter parameter without leading 'p'
-    os << "&" << startLowerCase(strip(commandData.params[it->first].name, "p"));
-  }
-  else
-  {
-    // the corresponding vector parameter is not the return parameter, or it's not a two-step algorithm
-    if (singular)
-    {
-      // for the singular version, the count is just 1.
-      os << "1 ";
-    }
-    else
-    {
-      // for the non-singular version, the count is the size of the vector parameter
-      // -> use the vector parameter name without leading 'p' to get the size (in number of elements, not in bytes)
-      os << startLowerCase(strip(commandData.params[it->second].name, "p")) << ".size() ";
-    }
-    if (commandData.templateParam == it->second)
-    {
-      // if the vector parameter is templatized -> multiply by the size of that type to get the size in bytes
-      os << "* sizeof( T ) ";
-    }
-  }
-}
-
-void VulkanHppGenerator::writeCallPlainTypeParameter(std::ostream & os, ParamData const& paramData)
-{
-  // this parameter is just a plain type
-  if (paramData.type.back() == '*')
-  {
-    // it's a pointer
-    std::string parameterName = startLowerCase(strip(paramData.name, "p"));
-    if (paramData.type.find("const") != std::string::npos)
-    {
-      // it's a const pointer
-      if (paramData.pureType == "char")
-      {
-        // it's a const pointer to char -> it's a string -> get the data via c_str()
-        os << parameterName;
-        if (paramData.optional)
-        {
-          // it's optional -> might use nullptr
-          os << " ? " << parameterName << "->c_str() : nullptr";
-        }
-        else
-        {
-          os << ".c_str()";
-        }
-      }
-      else
-      {
-        // it's const pointer to something else -> just use the name
-        assert(!paramData.optional);
-        os << paramData.name;
-      }
-    }
-    else
-    {
-      // it's a non-const pointer, and char is the only type that occurs -> use the address of the parameter
-      assert(paramData.type.find("char") == std::string::npos);
-      os << "&" << parameterName;
-    }
-  }
-  else
-  {
-    // it's a plain parameter -> just use its name
-    os << paramData.name;
-  }
-}
-
-void VulkanHppGenerator::writeCallVectorParameter(std::ostream & os, CommandData const& commandData, bool firstCall, bool singular, std::map<size_t, size_t>::const_iterator it)
-{
-  // this parameter is a vector parameter
-  assert(commandData.params[it->first].type.back() == '*');
-  if ((commandData.returnParam == it->first) && commandData.twoStep && firstCall)
-  {
-    // this parameter is the return parameter, and it's the first call of a two-step algorithm -> just just nullptr
-    os << "nullptr";
-  }
-  else
-  {
-    std::string parameterName = startLowerCase(strip(commandData.params[it->first].name, "p"));
-    std::set<std::string>::const_iterator vkit = m_vkTypes.find(commandData.params[it->first].pureType);
-    if ((vkit != m_vkTypes.end()) || (it->first == commandData.templateParam))
-    {
-      // CHECK for !commandData.params[it->first].optional
-
-      // this parameter is a vulkan type or a templated type -> need to reinterpret cast
-      writeReinterpretCast(os, commandData.params[it->first].type.find("const") == 0, vkit != m_vkTypes.end(), commandData.params[it->first].pureType, commandData.params[it->first].type.rfind("* const") != std::string::npos);
-      os << "( ";
-      if (singular)
-      {
-        // in singular case, strip the plural-S from the name, and use the pointer to that thing
-        os << "&" << stripPluralS(parameterName);
-      }
-      else
-      {
-        // in plural case, get the pointer to the data
-        os << parameterName << ".data()";
-      }
-      os << " )";
-    }
-    else if (commandData.params[it->first].pureType == "char")
-    {
-      // the parameter is a vector to char -> it might be optional
-      // besides that, the parameter now is a std::string -> get the pointer via c_str()
-      os << parameterName;
-      if (commandData.params[it->first].optional)
-      {
-        os << " ? " << parameterName << "->c_str() : nullptr";
-      }
-      else
-      {
-        os << ".c_str()";
-      }
-    }
-    else
-    {
-      // this parameter is just a vetor -> get the pointer to its data
-      os << parameterName << ".data()";
-    }
-  }
-}
-
-void VulkanHppGenerator::writeCallVulkanTypeParameter(std::ostream & os, ParamData const& paramData)
-{
-  // this parameter is a vulkan type
-  if (paramData.type.back() == '*')
-  {
-    // it's a pointer -> needs a reinterpret cast to the vulkan type
-    std::string parameterName = startLowerCase(strip(paramData.name, "p"));
-    writeReinterpretCast(os, paramData.type.find("const") != std::string::npos, true, paramData.pureType, false);
-    os << "( ";
-    if (paramData.optional)
-    {
-      // for an optional parameter, we need also a static_cast from optional type to const-pointer to pure type
-      os << "static_cast<const " << paramData.pureType << "*>( " << parameterName << " )";
-    }
-    else
-    {
-      // other parameters can just use the pointer
-      os << "&" << parameterName;
-    }
-    os << " )";
-  }
-  else
-  {
-    // a non-pointer parameter needs a static_cast from vk::-type to vulkan type
-    os << "static_cast<Vk" << paramData.pureType << ">( " << paramData.name << " )";
-  }
-}
-
-void VulkanHppGenerator::writeEnumsToString(std::ostream & os, EnumData const& enumData)
-{
-  // the helper functions to make strings out of enum values
-  enterProtect(os, enumData.protect);
-  os << "  VULKAN_HPP_INLINE std::string to_string(" << enumData.name << (enumData.values.empty() ? ")" : " value)") << std::endl
-    << "  {" << std::endl;
-  if (enumData.values.empty())
-  {
-    // no enum values in this enum -> return "(void)"
-    os << "    return \"(void)\";" << std::endl;
-  }
-  else
-  {
-    // otherwise switch over the value and return the a stringized version of that value (without leading 'e')
-    os << "    switch (value)" << std::endl
-      << "    {" << std::endl;
-    for (auto const& value : enumData.values)
-    {
-      os << "    case " << enumData.name << "::" << value.name << ": return \"" << value.name.substr(1) << "\";" << std::endl;
-    }
-    os << "    default: return \"invalid\";" << std::endl
-      << "    }" << std::endl;
-  }
-  os << "  }" << std::endl;
-  leaveProtect(os, enumData.protect);
-  os << std::endl;
-}
-
-// Intended only for `enum class Result`!
-void VulkanHppGenerator::writeExceptionsForEnum(std::ostream & os, EnumData const& enumData)
-{
-  std::string templateString =
-    R"(  class ${className} : public SystemError
-  {
-  public:
-    ${className}( std::string const& message )
-      : SystemError( make_error_code( ${enumName}::${enumMemberName} ), message ) {}
-    ${className}( char const * message )
-      : SystemError( make_error_code( ${enumName}::${enumMemberName} ), message ) {}
-  };
-)";
-
-  enterProtect(os, enumData.protect);
-  for (size_t i = 0; i < enumData.values.size(); i++)
-  {
-    if (!isErrorEnum(enumData.values[i].name))
-    {
-      continue;
-    }
-    os << replaceWithMap(templateString,
-    { { "className", stripErrorEnumPrefix(enumData.values[i].name) + "Error" },
-    { "enumName", enumData.name },
-    { "enumMemberName", enumData.values[i].name }
-    });
-  }
-  leaveProtect(os, enumData.protect);
-  os << std::endl;
-}
-
-void VulkanHppGenerator::writeFunction(std::ostream & os, std::string const& indentation, CommandData const& commandData, bool definition, bool enhanced, bool singular, bool unique, bool isStructureChain, bool withAllocator)
-{
-  writeFunctionHeaderTemplate(os, indentation, commandData, enhanced, singular, unique, !definition, isStructureChain);
-
-  os << indentation << (definition ? "VULKAN_HPP_INLINE " : "");
-  writeFunctionHeaderReturnType(os, commandData, enhanced, singular, unique, isStructureChain);
-  if (definition && !commandData.className.empty())
-  {
-    os << commandData.className << "::";
-  }
-  writeFunctionHeaderName(os, commandData.reducedName, singular, unique);
-  writeFunctionHeaderArguments(os, commandData, enhanced, singular, !definition, withAllocator);
-  os << (definition ? "" : ";") << std::endl;
-
-  if (definition)
-  {
-    // write the function body
-    os << indentation << "{" << std::endl;
-    if (enhanced)
-    {
-      writeFunctionBodyEnhanced(os, indentation, commandData, singular, unique, isStructureChain, withAllocator);
-    }
-    else
-    {
-      writeFunctionBodyStandard(os, indentation, commandData);
-    }
-    os << indentation << "}" << std::endl;
-  }
-}
-
-void VulkanHppGenerator::writeFunctionBodyEnhanced(std::ostream & os, std::string const& indentation, CommandData const& commandData, bool singular, bool unique, bool isStructureChain, bool withAllocator)
-{
-  if (unique && !singular && (commandData.vectorParams.find(commandData.returnParam) != commandData.vectorParams.end()))    // returns a vector of UniqueStuff
-  {
-    std::string const stringTemplate =
-R"(${i}  static_assert( sizeof( ${type} ) <= sizeof( UniqueHandle<${type}, Dispatch> ), "${type} is greater than UniqueHandle<${type}, Dispatch>!" );
-${i}  std::vector<UniqueHandle<${type}, Dispatch>, Allocator> ${typeVariable}s${allocator};
-${i}  ${typeVariable}s.reserve( ${vectorSize} );
-${i}  ${type}* buffer = reinterpret_cast<${type}*>( reinterpret_cast<char*>( ${typeVariable}s.data() ) + ${vectorSize} * ( sizeof( UniqueHandle<${type}, Dispatch> ) - sizeof( ${type} ) ) );
-${i}  Result result = static_cast<Result>(d.vk${command}( m_device, ${arguments}, reinterpret_cast<Vk${type}*>( buffer ) ) );
-
-${i}  ${Deleter}<${DeleterTemplate},Dispatch> deleter( *this, ${deleterArg}, d );
-${i}  for ( size_t i=0 ; i<${vectorSize} ; i++ )
-${i}  {
-${i}    ${typeVariable}s.push_back( UniqueHandle<${type}, Dispatch>( buffer[i], deleter ) );
-${i}  }
-
-${i}  return createResultValue( result, ${typeVariable}s, VULKAN_HPP_NAMESPACE_STRING "::${class}::${function}Unique" );
-)";
-
-    std::string type = (commandData.returnParam != INVALID_INDEX) ? commandData.params[commandData.returnParam].pureType : "";
-    std::string typeVariable = startLowerCase(type);
-    std::ostringstream arguments;
-    writeArguments(arguments, commandData, true, singular, 1, commandData.params.size() - 1);
-
-    std::map<std::string, DeleterData>::const_iterator ddit = m_deleters.find(type);
-    assert(ddit != m_deleters.end());
-
-    bool isCreateFunction = (commandData.fullName.substr(0, 6) == "create");
-    os << replaceWithMap(stringTemplate, std::map<std::string, std::string>
-    {
-      { "i", indentation },
-      { "type", type },
-      { "typeVariable", typeVariable },
-      { "allocator", withAllocator ? "( vectorAllocator )" : "" },
-      { "vectorSize", isCreateFunction ? "createInfos.size()" : "allocateInfo." + typeVariable + "Count" },
-      { "command", startUpperCase(commandData.fullName) },
-      { "arguments", arguments.str() },
-      { "Deleter", ddit->second.pool.empty() ? "ObjectDestroy" : "PoolFree" },
-      { "DeleterTemplate", ddit->second.pool.empty() ? commandData.className : commandData.className + "," + ddit->second.pool },
-      { "deleterArg", ddit->second.pool.empty() ? "allocator" : "allocateInfo." + startLowerCase(ddit->second.pool) },
-      { "class", commandData.className },
-      { "function", commandData.reducedName }
-    });
-  }
-  else
-  {
-    if (1 < commandData.vectorParams.size())
-    {
-      writeFunctionBodyEnhancedMultiVectorSizeCheck(os, indentation, commandData);
-    }
-
-    std::string returnName;
-    if (commandData.returnParam != INVALID_INDEX)
-    {
-      returnName = writeFunctionBodyEnhancedLocalReturnVariable(os, indentation, commandData, singular, isStructureChain, withAllocator);
-    }
-
-    if (commandData.twoStep)
-    {
-      assert(!singular);
-      writeFunctionBodyEnhancedLocalCountVariable(os, indentation, commandData);
-
-      // we now might have to check the result, resize the returned vector accordingly, and call the function again
-      std::map<size_t, size_t>::const_iterator returnit = commandData.vectorParams.find(commandData.returnParam);
-      assert(returnit != commandData.vectorParams.end() && (returnit->second != INVALID_INDEX));
-      std::string sizeName = startLowerCase(strip(commandData.params[returnit->second].name, "p"));
-
-      if (commandData.returnType == "Result")
-      {
-        if (1 < commandData.successCodes.size())
-        {
-          writeFunctionBodyEnhancedCallTwoStepIterate(os, indentation, returnName, sizeName, commandData);
-        }
-        else
-        {
-          writeFunctionBodyEnhancedCallTwoStepChecked(os, indentation, returnName, sizeName, commandData);
-        }
-      }
-      else
-      {
-        writeFunctionBodyEnhancedCallTwoStep(os, indentation, returnName, sizeName, commandData);
-      }
-    }
-    else
-    {
-      if (commandData.returnType == "Result")
-      {
-        writeFunctionBodyEnhancedCallResult(os, indentation, commandData, singular);
-      }
-      else
-      {
-        writeFunctionBodyEnhancedCall(os, indentation, commandData, singular);
-      }
-    }
-
-    if ((commandData.returnType == "Result") || !commandData.successCodes.empty())
-    {
-      writeFunctionBodyEnhancedReturnResultValue(os, indentation, returnName, commandData, singular, unique);
-    }
-    else if ((commandData.returnParam != INVALID_INDEX) && (commandData.returnType != commandData.enhancedReturnType))
-    {
-      // for the other returning cases, when the return type is somhow enhanced, just return the local returnVariable
-      os << indentation << "  return " << returnName << ";" << std::endl;
-    }
-  }
-}
-
-void VulkanHppGenerator::writeFunctionBodyEnhanced(std::ostream &os, std::string const& templateString, std::string const& indentation, CommandData const& commandData, bool singular)
-{
-  os << replaceWithMap(templateString, {
-    { "call", generateCall(commandData, true, singular) },
-    { "i", indentation }
-  });
-}
-
-void VulkanHppGenerator::writeFunctionBodyTwoStep(std::ostream & os, std::string const &templateString, std::string const& indentation, std::string const& returnName, std::string const& sizeName, CommandData const& commandData)
-{
-  std::map<std::string, std::string> replacements = {
-    { "sizeName", sizeName },
-    { "returnName", returnName },
-    { "call1", generateCall(commandData, true, false) },
-    { "call2", generateCall(commandData, false, false) },
-    { "i", indentation }
-  };
-
-  os << replaceWithMap(templateString, replacements);
-}
-
-std::string VulkanHppGenerator::writeFunctionBodyEnhancedLocalReturnVariable(std::ostream & os, std::string const& indentation, CommandData const& commandData, bool singular, bool isStructureChain, bool withAllocator)
-{
-  std::string returnName = startLowerCase(strip(commandData.params[commandData.returnParam].name, "p"));
-
-  // there is a returned parameter -> we need a local variable to hold that value
-  if (commandData.returnType != commandData.enhancedReturnType)
-  {
-    // the returned parameter is somehow enhanced by us
-    os << indentation << "  ";
-    if (singular)
-    {
-      if (isStructureChain)
-      {
-        std::string const &pureType = commandData.params[commandData.returnParam].pureType;
-        // For StructureChains use the template parameters
-        os << "StructureChain<X, Y, Z...> structureChain;" << std::endl;
-        returnName = stripPluralS(returnName);
-        os << indentation << "  " << pureType << "& " << returnName << " = structureChain.template get<" << pureType << ">()";
-        returnName = "structureChain";
-      }
-      else
-      {
-        // in singular case, just use the return parameters pure type for the return variable
-        returnName = stripPluralS(returnName);
-        os << commandData.params[commandData.returnParam].pureType << " " << returnName;
-      }
-    }
-    else
-    {
-      // in non-singular case, use the enhanced type for the return variable (like vector<...>)
-      if (isStructureChain)
-      {
-        std::string const &returnType = commandData.enhancedReturnType;
-        // For StructureChains use the template parameters
-        os << "StructureChain<X, Y, Z...> structureChain;" << std::endl;
-        os << indentation << "  " << returnType << "& " << returnName << " = structureChain.template get<" << returnType << ">()";
-        returnName = "structureChain";
-      }
-      else
-      {
-        os << commandData.enhancedReturnType << " " << returnName;
-      }
-
-      std::map<size_t, size_t>::const_iterator it = commandData.vectorParams.find(commandData.returnParam);
-      if (it != commandData.vectorParams.end() && !commandData.twoStep)
-      {
-        // if the return parameter is a vector parameter, and not part of a two-step algorithm, initialize its size
-        std::string size;
-        if (it->second == INVALID_INDEX)
-        {
-          assert(!commandData.params[commandData.returnParam].len.empty());
-          // the size of the vector is not given by an other parameter, but by some member of a parameter, described as 'parameter::member'
-          // -> replace the '::' by '.' and filter out the leading 'p' to access that value
-          size = startLowerCase(strip(commandData.params[commandData.returnParam].len, "p"));
-          size_t pos = size.find("::");
-          assert(pos != std::string::npos);
-          size.replace(pos, 2, ".");
-        }
-        else
-        {
-          // the size of the vector is given by an other parameter
-          // first check, if that size has become the size of some other vector parameter
-          // -> look for it and get it's actual size
-          for (auto const& vectorParam : commandData.vectorParams)
-          {
-            if ((vectorParam.first != it->first) && (vectorParam.second == it->second))
-            {
-              size = startLowerCase(strip(commandData.params[vectorParam.first].name, "p")) + ".size()";
-              break;
-            }
-          }
-          if (size.empty())
-          {
-            // otherwise, just use that parameter
-            size = commandData.params[it->second].name;
-          }
-        }
-        assert(!size.empty());
-        os << "( " << size << (withAllocator ? ", vectorAllocator" : "") << " )";
-      }
-      else if (withAllocator)
-      {
-        os << "( vectorAllocator )";
-      }
-    }
-    os << ";" << std::endl;
-  }
-  else
-  {
-    // the return parameter is not enhanced -> the type is supposed to be a Result and there are more than one success codes!
-    assert((commandData.returnType == "Result") && (1 < commandData.successCodes.size()));
-    os << indentation << "  " << commandData.params[commandData.returnParam].pureType << " " << returnName << ";" << std::endl;
-  }
-
-  return returnName;
-}
-
-void VulkanHppGenerator::writeFunctionBodyEnhancedCall(std::ostream &os, std::string const& indentation, CommandData const& commandData, bool singular)
-{
-  std::string const templateString = "${i}  return ${call};\n";
-  std::string const templateStringVoid = "${i}  ${call};\n";
-  writeFunctionBodyEnhanced(os, commandData.returnType == "void" ? templateStringVoid : templateString, indentation, commandData, singular);
-}
-
-void VulkanHppGenerator::writeFunctionBodyEnhancedCallResult(std::ostream &os, std::string const& indentation, CommandData const& commandData, bool singular)
-{
-  std::string const templateString = "${i}  Result result = static_cast<Result>( ${call} );\n";
-  writeFunctionBodyEnhanced(os, templateString, indentation, commandData, singular);
-}
-
-void VulkanHppGenerator::writeFunctionBodyEnhancedCallTwoStep(std::ostream & os, std::string const& indentation, std::string const& returnName, std::string const& sizeName, CommandData const& commandData)
-{
-  std::string const templateString =
-    R"(${i}  ${call1};
-${i}  ${returnName}.resize( ${sizeName} );
-${i}  ${call2};
-)";
-  writeFunctionBodyTwoStep(os, templateString, indentation, returnName, sizeName, commandData);
-}
-
-void VulkanHppGenerator::writeFunctionBodyEnhancedCallTwoStepIterate(std::ostream & os, std::string const& indentation, std::string const& returnName, std::string const& sizeName, CommandData const& commandData)
-{
-  std::string const templateString =
-    R"(${i}  Result result;
-${i}  do
-${i}  {
-${i}    result = static_cast<Result>( ${call1} );
-${i}    if ( ( result == Result::eSuccess ) && ${sizeName} )
-${i}    {
-${i}      ${returnName}.resize( ${sizeName} );
-${i}      result = static_cast<Result>( ${call2} );
-${i}    }
-${i}  } while ( result == Result::eIncomplete );
-${i}  if ( result == Result::eSuccess )
-${i}  {
-${i}    VULKAN_HPP_ASSERT( ${sizeName} <= ${returnName}.size() );
-${i}    ${returnName}.resize( ${sizeName} );
-${i}  }
-)";
-  writeFunctionBodyTwoStep(os, templateString, indentation, returnName, sizeName, commandData);
-}
-
-void VulkanHppGenerator::writeFunctionBodyEnhancedCallTwoStepChecked(std::ostream & os, std::string const& indentation, std::string const& returnName, std::string const& sizeName, CommandData const& commandData)
-{
-  std::string const templateString =
-    R"(${i}  Result result = static_cast<Result>( ${call1} );
-${i}  if ( ( result == Result::eSuccess ) && ${sizeName} )
-${i}  {
-${i}    ${returnName}.resize( ${sizeName} );
-${i}    result = static_cast<Result>( ${call2} );
-${i}  }
-)";
-  writeFunctionBodyTwoStep(os, templateString, indentation, returnName, sizeName, commandData);
-}
-
-void VulkanHppGenerator::writeFunctionBodyEnhancedLocalCountVariable(std::ostream & os, std::string const& indentation, CommandData const& commandData)
-{
-  // local count variable to hold the size of the vector to fill
-  assert(commandData.returnParam != INVALID_INDEX);
-
-  std::map<size_t, size_t>::const_iterator returnit = commandData.vectorParams.find(commandData.returnParam);
-  assert(returnit != commandData.vectorParams.end() && (returnit->second != INVALID_INDEX));
-  assert((commandData.returnType == "Result") || (commandData.returnType == "void"));
-
-  // take the pure type of the size parameter; strip the leading 'p' from its name for its local name
-  os << indentation << "  " << commandData.params[returnit->second].pureType << " " << startLowerCase(strip(commandData.params[returnit->second].name, "p")) << ";" << std::endl;
-}
-
-void VulkanHppGenerator::writeFunctionBodyEnhancedMultiVectorSizeCheck(std::ostream & os, std::string const& indentation, CommandData const& commandData)
-{
-  std::string const templateString =
-    R"#(#ifdef VULKAN_HPP_NO_EXCEPTIONS
-${i}  VULKAN_HPP_ASSERT( ${firstVectorName}.size() == ${secondVectorName}.size() );
-#else
-${i}  if ( ${firstVectorName}.size() != ${secondVectorName}.size() )
-${i}  {
-${i}    throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::${className}::${reducedName}: ${firstVectorName}.size() != ${secondVectorName}.size()" );
-${i}  }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-)#";
-
-
-  // add some error checks if multiple vectors need to have the same size
-  for (std::map<size_t, size_t>::const_iterator it0 = commandData.vectorParams.begin(); it0 != commandData.vectorParams.end(); ++it0)
-  {
-    if (it0->first != commandData.returnParam)
-    {
-      for (std::map<size_t, size_t>::const_iterator it1 = std::next(it0); it1 != commandData.vectorParams.end(); ++it1)
-      {
-        if ((it1->first != commandData.returnParam) && (it0->second == it1->second))
-        {
-          os << replaceWithMap(templateString, std::map<std::string, std::string>({
-            { "firstVectorName", startLowerCase(strip(commandData.params[it0->first].name, "p")) },
-            { "secondVectorName", startLowerCase(strip(commandData.params[it1->first].name, "p")) },
-            { "className", commandData.className },
-            { "reducedName", commandData.reducedName },
-            { "i", indentation }
-          }));
-        }
-      }
-    }
-  }
-}
-
-void VulkanHppGenerator::writeFunctionBodyEnhancedReturnResultValue(std::ostream & os, std::string const& indentation, std::string const& returnName, CommandData const& commandData, bool singular, bool unique)
-{
-  std::string type = (commandData.returnParam != INVALID_INDEX) ? commandData.params[commandData.returnParam].pureType : "";
-  std::string returnVectorName = (commandData.returnParam != INVALID_INDEX) ? strip(commandData.params[commandData.returnParam].name, "p", "s") : "";
-
-  if (unique)
-  {
-    // the unique version needs a Deleter object for destruction of the newly created stuff
-    // get the DeleterData corresponding to the returned type
-    std::map<std::string, DeleterData>::const_iterator ddit = m_deleters.find(type);
-    assert(ddit != m_deleters.end() && ddit->second.pool.empty());
-
-    // special handling for "createDevice", as Device is created from PhysicalDevice, but destroyed on its own
-    bool noParent = commandData.className.empty() || (commandData.fullName == "createDevice");
-    os << std::endl
-      << indentation << ((commandData.fullName == "allocateMemory") ? "  ObjectFree<" : "  ObjectDestroy<") << (noParent ? "NoParent" : commandData.className) << ",Dispatch> deleter( " << (noParent ? "" : "*this, ") << "allocator, d );" << std::endl
-      << indentation << "  return createResultValue<" << type << ",Dispatch>( result, ";
-  }
-  else
-  {
-    os << indentation << "  return createResultValue( result, ";
-  }
-
-  // if the return type is "Result" or there is at least one success code, create the Result/Value construct to return
-  if (commandData.returnParam != INVALID_INDEX)
-  {
-    // if there's a return parameter, list it in the Result/Value constructor
-    os << returnName << ", ";
-  }
-
-  // now the function name (with full namespace) as a string
-  os << "VULKAN_HPP_NAMESPACE_STRING\"::" << (commandData.className.empty() ? "" : commandData.className + "::") << (singular ? stripPluralS(commandData.reducedName) : commandData.reducedName) << (unique ? "Unique" : "") << "\"";
-
-  if (!commandData.twoStep && (1 < commandData.successCodes.size()))
-  {
-    // and for the single-step algorithms with more than one success code list them all
-    os << ", { Result::" << commandData.successCodes[0];
-    for (size_t i = 1; i < commandData.successCodes.size(); i++)
-    {
-      os << ", Result::" << commandData.successCodes[i];
-    }
-    os << " }";
-  }
-
-  if (unique)
-  {
-    os << ", deleter";
-  }
-
-  os << " );" << std::endl;
-}
-
-void VulkanHppGenerator::writeFunctionBodyStandard(std::ostream & os, std::string const& indentation, CommandData const& commandData)
-{
-  os << indentation << "  ";
-  bool castReturn = false;
-  if (commandData.returnType != "void")
-  {
-    // there's something to return...
-    os << "return ";
-
-    castReturn = (m_vkTypes.find(commandData.returnType) != m_vkTypes.end());
-    if (castReturn)
-    {
-      // the return-type is a vulkan type -> need to cast to vk::-type
-      os << "static_cast<" << commandData.returnType << ">( ";
-    }
-  }
-
-  // call the original function
-  os << "d.vk" << startUpperCase(commandData.fullName) << "( ";
-
-  if (!commandData.className.empty())
-  {
-    // the command is part of a class -> the first argument is the member variable, starting with "m_"
-    assert(commandData.className == commandData.params[0].type);
-    os << "m_" << startLowerCase(commandData.className);
-  }
-
-  // list all the arguments
-  for (size_t i = commandData.className.empty() ? 0 : 1; i < commandData.params.size(); i++)
-  {
-    if (0 < i)
-    {
-      os << ", ";
-    }
-
-    if (m_vkTypes.find(commandData.params[i].pureType) != m_vkTypes.end())
-    {
-      // the parameter is a vulkan type
-      if (commandData.params[i].type.back() == '*')
-      {
-        // it's a pointer -> need to reinterpret_cast it
-        writeReinterpretCast(os, commandData.params[i].type.find("const") == 0, true, commandData.params[i].pureType, commandData.params[i].type.find("* const") != std::string::npos);
-      }
-      else
-      {
-        // it's a value -> need to static_cast ist
-        os << "static_cast<Vk" << commandData.params[i].pureType << ">";
-      }
-      os << "( " << commandData.params[i].name << " )";
-    }
-    else
-    {
-      // it's a non-vulkan type -> just use it
-      os << commandData.params[i].name;
-    }
-  }
-  os << " )";
-
-  if (castReturn)
-  {
-    // if we cast the return -> close the static_cast
-    os << " )";
-  }
-  os << ";" << std::endl;
-}
-
-void VulkanHppGenerator::writeFunctionHeaderArguments(std::ostream & os, CommandData const& commandData, bool enhanced, bool singular, bool withDefaults, bool withAllocator)
-{
-  os << "(";
-  if (enhanced)
-  {
-    writeFunctionHeaderArgumentsEnhanced(os, commandData, singular, withDefaults, withAllocator);
-  }
-  else
-  {
-    writeFunctionHeaderArgumentsStandard(os, commandData, withDefaults);
-  }
-  os << ")";
-  if (!commandData.className.empty())
-  {
-    os << " const";
-  }
-}
-
-void VulkanHppGenerator::writeFunctionHeaderArgumentsEnhanced(std::ostream & os, CommandData const& commandData, bool singular, bool withDefaults, bool withAllocator)
-{
-  // check if there's at least one argument left to put in here
-  if (commandData.skippedParams.size() + (commandData.className.empty() ? 0 : 1) < commandData.params.size())
-  {
-    // determine the last argument, where we might provide some default for
-    size_t lastArgument = INVALID_INDEX;
-    for (size_t i = commandData.params.size() - 1; i < commandData.params.size(); i--)
-    {
-      if (commandData.skippedParams.find(i) == commandData.skippedParams.end())
-      {
-        lastArgument = i;
-        break;
-      }
-    }
-
-    os << " ";
-    bool argEncountered = false;
-    for (size_t i = commandData.className.empty() ? 0 : 1; i < commandData.params.size(); i++)
-    {
-      if (commandData.skippedParams.find(i) == commandData.skippedParams.end())
-      {
-        if (argEncountered)
-        {
-          os << ", ";
-        }
-        std::string strippedParameterName = startLowerCase(strip(commandData.params[i].name, "p"));
-
-        std::map<size_t, size_t>::const_iterator it = commandData.vectorParams.find(i);
-        size_t rightStarPos = commandData.params[i].type.rfind('*');
-        if (it == commandData.vectorParams.end())
-        {
-          // the argument ist not a vector
-          if (rightStarPos == std::string::npos)
-          {
-            // and its not a pointer -> just use its type and name here
-            os << commandData.params[i].type << " " << commandData.params[i].name;
-            if (!commandData.params[i].arraySize.empty())
-            {
-              os << "[" << commandData.params[i].arraySize << "]";
-            }
-
-            if (withDefaults && (lastArgument == i) && !withAllocator)
-            {
-              // check if the very last argument is a flag without any bits -> provide some empty default for it
-              std::map<std::string, BitmaskData>::const_iterator bitmasksIt = m_bitmasks.find(commandData.params[i].pureType);
-              if (bitmasksIt != m_bitmasks.end())
-              {
-                // get the enum corresponding to this flag, to check if it's empty
-                std::list<DependencyData>::const_iterator depIt = std::find_if(m_dependencies.begin(), m_dependencies.end(), [&bitmasksIt](DependencyData const& dd) { return(dd.name == bitmasksIt->first); });
-                assert((depIt != m_dependencies.end()) && (depIt->dependencies.size() == 1));
-                std::map<std::string, EnumData>::const_iterator enumIt = m_enums.find(*depIt->dependencies.begin());
-                assert(enumIt != m_enums.end());
-                if (enumIt->second.values.empty())
-                {
-                  // there are no bits in this flag -> provide the default
-                  os << " = " << commandData.params[i].pureType << "()";
-                }
-              }
-            }
-          }
-          else
-          {
-            // the argument is not a vector, but a pointer
-            assert(commandData.params[i].type[rightStarPos] == '*');
-            if (commandData.params[i].optional)
-            {
-              // for an optional argument, trim the trailing '*' from the type, and the leading 'p' from the name
-              os << "Optional<" << trimEnd(commandData.params[i].type.substr(0, rightStarPos)) << "> " << strippedParameterName;
-              if (withDefaults && !withAllocator)
-              {
-                os << " = nullptr";
-              }
-            }
-            else if (commandData.params[i].pureType == "void")
-            {
-              // for void-pointer, just use type and name
-              os << commandData.params[i].type << " " << commandData.params[i].name;
-            }
-            else if (commandData.params[i].pureType != "char")
-            {
-              // for non-char-pointer, change to reference
-              os << trimEnd(commandData.params[i].type.substr(0, rightStarPos)) << " & " << strippedParameterName;
-            }
-            else
-            {
-              // for char-pointer, change to const reference to std::string
-              os << "const std::string & " << strippedParameterName;
-            }
-          }
-        }
-        else
-        {
-          // the argument is a vector
-          // it's optional, if it's marked as optional and there's no size specified
-          bool optional = commandData.params[i].optional && (it->second == INVALID_INDEX);
-          assert((rightStarPos != std::string::npos) && (commandData.params[i].type[rightStarPos] == '*'));
-          if (commandData.params[i].type.find("char") != std::string::npos)
-          {
-            // it's a char-vector -> use a std::string (either optional or a const-reference
-            if (optional)
-            {
-              os << "Optional<const std::string> " << strippedParameterName;
-              if (withDefaults && !withAllocator)
-              {
-                os << " = nullptr";
-              }
-            }
-            else
-            {
-              os << "const std::string & " << strippedParameterName;
-            }
-          }
-          else
-          {
-            // it's a non-char vector (they are never optional)
-            assert(!optional);
-            if (singular)
-            {
-              // in singular case, change from pointer to reference
-              os << trimEnd(commandData.params[i].type.substr(0, rightStarPos)) << " & " << stripPluralS(strippedParameterName);
-            }
-            else
-            {
-              // otherwise, use our ArrayProxy
-              bool isConst = (commandData.params[i].type.find("const") != std::string::npos);
-              os << "ArrayProxy<" << ((commandData.templateParam == i) ? (isConst ? "const T" : "T") : trimEnd(commandData.params[i].type.substr(0, rightStarPos))) << "> " << strippedParameterName;
-            }
-          }
-        }
-        argEncountered = true;
-      }
-    }
-
-    if (argEncountered)
-    {
-      os << ", ";
-    }
-  }
-  if (withAllocator)
-  {
-    os << "Allocator const& vectorAllocator, ";
-  }
-  os << "Dispatch const &d";
-  if (withDefaults && !withAllocator)
-  {
-    os << " = Dispatch()";
-  }
-
-  os << " ";
-}
-
-void VulkanHppGenerator::writeFunctionHeaderArgumentsStandard(std::ostream & os, CommandData const& commandData, bool withDefaults)
-{
-  // for the standard case, just list all the arguments as we've got them
-  bool argEncountered = false;
-
-  // determine the last argument, where we might provide some default for
-  size_t lastArgument = commandData.params.size() - 1;
-
-  for (size_t i = commandData.className.empty() ? 0 : 1; i < commandData.params.size(); i++)
-  {
-    if (argEncountered)
-    {
-      os << ",";
-    }
-
-    os << " " << commandData.params[i].type << " " << commandData.params[i].name;
-    if (!commandData.params[i].arraySize.empty())
-    {
-      os << "[" << commandData.params[i].arraySize << "]";
-    }
-
-    if (withDefaults && (lastArgument == i))
-    {
-      // check if the very last argument is a flag without any bits -> provide some empty default for it
-      std::map<std::string, BitmaskData>::const_iterator flagIt = m_bitmasks.find(commandData.params[i].pureType);
-      if (flagIt != m_bitmasks.end())
-      {
-        // get the enum corresponding to this flag, to check if it's empty
-        std::list<DependencyData>::const_iterator depIt = std::find_if(m_dependencies.begin(), m_dependencies.end(), [&flagIt](DependencyData const& dd) { return(dd.name == flagIt->first); });
-        assert((depIt != m_dependencies.end()) && (depIt->dependencies.size() == 1));
-        std::map<std::string, EnumData>::const_iterator enumIt = m_enums.find(*depIt->dependencies.begin());
-        assert(enumIt != m_enums.end());
-        if (enumIt->second.values.empty())
-        {
-          // there are no bits in this flag -> provide the default
-          os << " = " << commandData.params[i].pureType << "()";
-        }
-      }
-    }
-    argEncountered = true;
-  }
-  if (argEncountered)
-  {
-    os << ", ";
-  }
-
-  os << "Dispatch const &d";
-  if (withDefaults)
-  {
-    os << " = Dispatch() ";
-  }
-}
-
-void VulkanHppGenerator::writeFunctionHeaderReturnType(std::ostream & os, CommandData const& commandData, bool enhanced, bool singular, bool unique, bool isStructureChain)
-{
-  std::string templateString;
-  std::string returnType;
-  if (enhanced)
-  {
-    // the enhanced function might return some pretty complex return stuff
-    if (isStructureChain || (!singular && (commandData.enhancedReturnType.find("Allocator") != std::string::npos)))
-    {
-      // for the non-singular case with allocation, we need to prepend with 'typename' to keep compilers happy
-      templateString = "typename ";
-    }
-    if (unique)
-    {
-      // the unique version returns something prefixed with 'Unique'; potentially a vector of that stuff
-      // it's a vector, if it's not the singular version and the return parameter is a vector parameter
-      bool returnsVector = !singular && (commandData.vectorParams.find(commandData.returnParam) != commandData.vectorParams.end());
-
-      templateString += returnsVector ? "ResultValueType<std::vector<UniqueHandle<${returnType},Dispatch>,Allocator>>::type " : "typename ResultValueType<UniqueHandle<${returnType},Dispatch>>::type ";
-      returnType = isStructureChain ? "StructureChain<X, Y, Z...>" : commandData.params[commandData.returnParam].pureType;
-    }
-    else if ((commandData.enhancedReturnType != commandData.returnType) && (commandData.returnType != "void"))
-    {
-      // if the enhanced return type differs from the original return type, and it's not void, we return a ResultValueType<...>::type
-      templateString += "ResultValueType<${returnType}>::type ";
-
-      assert(commandData.returnType == "Result");
-      // in singular case, we create the ResultValueType from the pure return type, otherwise from the enhanced return type
-      if (isStructureChain)
-      {
-        returnType = "StructureChain<X, Y, Z...>";
-      }
-      else
-      {
-        returnType = singular ? commandData.params[commandData.returnParam].pureType : commandData.enhancedReturnType;
-      }
-    }
-    else if ((commandData.returnParam != INVALID_INDEX) && (1 < commandData.successCodes.size()))
-    {
-      // if there is a return parameter at all, and there are multiple success codes, we return a ResultValue<...> with the pure return type
-      assert(commandData.returnType == "Result");
-      templateString = "ResultValue<${returnType}> ";
-      returnType = isStructureChain ? "StructureChain<X, Y, Z...>" : commandData.params[commandData.returnParam].pureType;
-    }
-    else
-    {
-      // and in every other case, we just return the enhanced return type.
-      templateString = "${returnType} ";
-      returnType = isStructureChain ? "StructureChain<X, Y, Z...>" : commandData.enhancedReturnType;
-    }
-  }
-  else
-  {
-    // the non-enhanced function just uses the return type
-    templateString = "${returnType} ";
-    returnType = commandData.returnType;
-  }
-  os << replaceWithMap(templateString, { { "returnType", returnType } });
-}
-
-void VulkanHppGenerator::writeFunctionHeaderTemplate(std::ostream & os, std::string const& indentation, CommandData const& commandData, bool enhanced, bool singular, bool unique, bool withDefault, bool isStructureChain)
-{
-  std::string dispatch = withDefault ? std::string("typename Dispatch = DispatchLoaderStatic") : std::string("typename Dispatch");
-  if (enhanced && isStructureChain)
-  {
-    os << indentation << "template <typename X, typename Y, typename ...Z, " << dispatch << ">" << std::endl;
-  }
-  else if (enhanced && (commandData.templateParam != INVALID_INDEX) && ((commandData.templateParam != commandData.returnParam) || (commandData.enhancedReturnType == "Result")))
-  {
-    // if there's a template parameter, not being the return parameter or where the enhanced return type is 'Result' -> templatize on type 'T'
-    assert(commandData.enhancedReturnType.find("Allocator") == std::string::npos);
-    os << indentation << "template <typename T, " << dispatch << ">" << std::endl;
-  }
-  else if (enhanced && !singular && (commandData.enhancedReturnType.find("Allocator") != std::string::npos))
-  {
-    // otherwise, if there's an Allocator used in the enhanced return type, we templatize on that Allocator
-    assert((commandData.enhancedReturnType.substr(0, 12) == "std::vector<") && (commandData.enhancedReturnType.find(',') != std::string::npos) && (12 < commandData.enhancedReturnType.find(',')));
-    os << indentation << "template <typename Allocator";
-    if (withDefault)
-    {
-      // for the default type get the type from the enhancedReturnType, which is of the form 'std::vector<Type,Allocator>'
-      os << " = std::allocator<" << (unique ? "Unique" : "") << commandData.enhancedReturnType.substr(12, commandData.enhancedReturnType.find(',') - 12) << ">";
-    }
-    os << ", " << dispatch;
-    os << "> " << std::endl;
-  }
-  else
-  {
-    os << indentation << "template<" << dispatch << ">" << std::endl;
-  }
-}
-
-void VulkanHppGenerator::writeResultEnum(std::ostream & os)
-{
-  std::list<DependencyData>::const_iterator it = std::find_if(m_dependencies.begin(), m_dependencies.end(), [](DependencyData const& dp) { return dp.name == "Result"; });
-  assert(it != m_dependencies.end());
-  writeTypeEnum(os, m_enums.find(it->name)->second);
-  writeEnumsToString(os, m_enums.find(it->name)->second);
-  os << "#ifndef VULKAN_HPP_NO_EXCEPTIONS";
-  os << exceptionHeader;
-  os << exceptionClassesHeader;
-  writeExceptionsForEnum(os, m_enums.find(it->name)->second);
-  writeThrowExceptions(os, m_enums.find(it->name)->second);
-  os << "#endif" << std::endl;
-  m_dependencies.erase(it);
-}
-
-void VulkanHppGenerator::writeStructConstructor(std::ostream & os, std::string const& name, StructData const& structData, std::map<std::string, std::string> const& defaultValues)
-{
-  // the constructor with all the elements as arguments, with defaults
-  std::string ctorOpening = "    " + name + "( ";
-  size_t indentSize = ctorOpening.size();
-  os << ctorOpening;
-
-  bool listedArgument = false;
-  for (size_t i = 0; i < structData.members.size(); i++)
-  {
-    listedArgument = writeStructConstructorArgument(os, listedArgument, indentSize, structData.members[i], defaultValues);
-  }
-  os << " )" << std::endl;
-
-  // copy over the simple arguments
-  bool firstArgument = true;
-  for (size_t i = 0; i < structData.members.size(); i++)
-  {
-    // 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 = structData.members[i].name + "_";   // the elements are initialized by the corresponding argument (with trailing '_', as mentioned above)
-
-      os << replaceWithMap(templateString, { { "sep", sep },{ "member", member },{ "value", value } });
-      firstArgument = false;
-    }
-  }
-
-  // the body of the constructor, copying over data from argument list into wrapped struct
-  os << "    {" << std::endl;
-  for (size_t i = 0; i < structData.members.size(); i++)
-  {
-    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 } });
-    }
-  }
-  os << "    }\n\n";
-
-  if (!structData.subStruct.empty())
-  {
-    auto const& subStruct = m_structs.find(structData.subStruct);
-    assert(subStruct != m_structs.end());
-
-    std::string subStructArgumentName = startLowerCase(strip(subStruct->first, "vk"));
-    ctorOpening = "    explicit " + name + "( ";
-    indentSize = ctorOpening.size();
-
-    os << ctorOpening << subStruct->first << " const& " << subStructArgumentName;
-
-    for (size_t i = subStruct->second.members.size(); i < structData.members.size(); i++)
-    {
-      writeStructConstructorArgument(os, true, indentSize, structData.members[i], defaultValues);
-    }
-    os << " )" << std::endl;
-
-    firstArgument = true;
-    std::string templateString = "      ${sep} ${member}( ${value} )\n";
-    for (size_t i = 0; i < subStruct->second.members.size(); i++)
-    {
-      assert(structData.members[i].arraySize.empty());
-      std::string sep = firstArgument ? ":" : ",";
-      std::string member = structData.members[i].name;
-      std::string value = subStructArgumentName + "." + subStruct->second.members[i].name;
-
-      os << replaceWithMap(templateString, { { "sep", sep },{ "member", member },{ "value", value } });
-      firstArgument = false;
-    }
-    for (size_t i = subStruct->second.members.size(); i < structData.members.size(); i++)
-    {
-      assert(structData.members[i].arraySize.empty());
-      std::string member = structData.members[i].name;
-      std::string value = structData.members[i].name + "_";   // the elements are initialized by the corresponding argument (with trailing '_', as mentioned above)
-
-      os << replaceWithMap(templateString, { { "sep", "," },{ "member", member },{ "value", value } });
-    }
-    os << "    {}" << std::endl << std::endl;
-  }
-
-  std::string templateString =
-    R"(    ${name}( Vk${name} const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ${name} ) );
-    }
-
-    ${name}& operator=( Vk${name} const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ${name} ) );
-      return *this;
-    }
-)";
-
-  os << replaceWithMap(templateString, { { "name", name } });
-}
-
-void VulkanHppGenerator::writeIndentation(std::ostream & os, size_t indentLength)
-{
-  for(size_t i = 0; i < indentLength; i++)
-  {
-    os << " ";
-  }
-}
-
-bool VulkanHppGenerator::writeStructConstructorArgument(std::ostream & os, bool listedArgument, size_t indentLength, MemberData const& memberData, std::map<std::string, std::string> const& defaultValues)
-{
-  if (listedArgument)
-  {
-    os << ",\n";
-    writeIndentation(os, indentLength);
-  }
-
-  // skip members 'pNext' and 'sType', as they are never explicitly set
-  if ((memberData.name != "pNext") && (memberData.name != "sType"))
-  {
-    // find a default value for the given pure type
-    std::map<std::string, std::string>::const_iterator defaultIt = defaultValues.find(memberData.pureType);
-    assert(defaultIt != defaultValues.end());
-
-    if (memberData.arraySize.empty())
-    {
-      // the arguments name get a trailing '_', to distinguish them from the actual struct members
-      // pointer arguments get a nullptr as default
-      os << memberData.type << " " << memberData.name << "_ = " << (memberData.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<" << memberData.type << "," << memberData.arraySize << "> const& " << memberData.name << "_ = { { " << defaultIt->second;
-      size_t n = atoi(memberData.arraySize.c_str());
-      assert(0 < n);
-      for (size_t j = 1; j < n; j++)
-      {
-        os << ", " << defaultIt->second;
-      }
-      os << " } }";
-    }
-    listedArgument = true;
-  }
-  return listedArgument;
-}
-
-void VulkanHppGenerator::writeStructSetter(std::ostream & os, std::string const& structureName, MemberData const& memberData)
-{
-  if (memberData.type != "StructureType") // filter out StructureType, which is supposed to be immutable !
-  {
-    // the setters return a reference to the structure
-    os << "    " << structureName << "& set" << startUpperCase(memberData.name) << "( ";
-    if (memberData.arraySize.empty())
-    {
-      os << memberData.type << " ";
-    }
-    else
-    {
-      os << "std::array<" << memberData.type << "," << memberData.arraySize << "> ";
-    }
-    // add a trailing '_' to the argument to distinguish it from the structure member
-    os << memberData.name << "_ )" << std::endl
-      << "    {" << std::endl;
-    // copy over the argument, either by assigning simple data, or by memcpy array data
-    if (memberData.arraySize.empty())
-    {
-      os << "      " << memberData.name << " = " << memberData.name << "_";
-    }
-    else
-    {
-      os << "      memcpy( &" << memberData.name << ", " << memberData.name << "_.data(), " << memberData.arraySize << " * sizeof( " << memberData.type << " ) )";
-    }
-    os << ";" << std::endl
-      << "      return *this;" << std::endl
-      << "    }" << std::endl
-      << std::endl;
-  }
-}
-
-void VulkanHppGenerator::writeStructureChainValidation(std::ostream & os)
-{
-  // write all template functions for the structure pointer chain validation
-  for (auto it = m_dependencies.begin(); it != m_dependencies.end(); ++it)
-  {
-    if (it->category == DependencyData::Category::STRUCT)
-    {
-      writeStructureChainValidation(os, *it);
-    }
-  }
-}
-
-void VulkanHppGenerator::writeStructureChainValidation(std::ostream & os, DependencyData const& dependencyData)
-{
-  std::map<std::string, StructData>::const_iterator it = m_structs.find(dependencyData.name);
-  assert(it != m_structs.end());
-
-  if (!it->second.structExtends.empty())
-  {
-    enterProtect(os, it->second.protect);
-
-    // write out allowed structure chains
-    for (auto extendName : it->second.structExtends)
-    {
-      std::map<std::string, StructData>::const_iterator itExtend = m_structs.find(extendName);
-      if (itExtend == m_structs.end()) {
-        std::stringstream errorString;
-        errorString << extendName << " does not specify a struct in structextends field.";
-
-        // check if symbol name is an alias to a struct
-        auto itAlias = std::find_if(m_structs.begin(), m_structs.end(), [&extendName](std::pair<std::string, StructData> const &it) -> bool {return it.second.alias == extendName;});
-        if (itAlias != m_structs.end())
-        {
-          errorString << " The symbol is an alias and maps to " << itAlias->first << ".";
-        }
-
-        errorString << std::endl;
-        throw std::runtime_error(errorString.str());
-      }
-      enterProtect(os, itExtend->second.protect);
-
-      os << "  template <> struct isStructureChainValid<" << extendName << ", " << dependencyData.name << ">{ enum { value = true }; };" << std::endl;
-
-      leaveProtect(os, itExtend->second.protect);
-    }
-    leaveProtect(os, it->second.protect);
-  }
-}
-
-void VulkanHppGenerator::writeThrowExceptions(std::ostream & os, EnumData const& enumData)
-{
-  enterProtect(os, enumData.protect);
-  os <<
-    R"(  VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
-  {
-    switch ( result )
-    {
-)";
-  for (size_t i = 0; i<enumData.values.size(); i++)
-  {
-    if (!isErrorEnum(enumData.values[i].name))
-    {
-      continue;
-    }
-    const std::string strippedExceptionName = stripErrorEnumPrefix(enumData.values[i].name);
-    os << "    case " << enumData.name << "::" << enumData.values[i].name << ": "
-      << "throw " << strippedExceptionName << "Error ( message );" << std::endl;
-  }
-  os <<
-    R"(    default: throw SystemError( make_error_code( result ) );
-    }
-  }
-)";
-  leaveProtect(os, enumData.protect);
-}
-
-void VulkanHppGenerator::writeToStringFunctions(std::ostream & os)
-{
-  // write all the to_string functions for enums and flags
-  for (auto it = m_dependencies.begin(); it != m_dependencies.end(); ++it)
-  {
-    switch (it->category)
-    {
-      case DependencyData::Category::BITMASK:
-        writeBitmaskToString(os, it->name, m_enums.find(*it->dependencies.begin())->second);
-        break;
-      case DependencyData::Category::ENUM:
-        assert(m_enums.find(it->name) != m_enums.end());
-        writeEnumsToString(os, m_enums.find(it->name)->second);
-        break;
-      default:
-        break;
-    }
-  }
-}
-
-void VulkanHppGenerator::writeTypeBitmask(std::ostream & os, std::string const& bitmaskName, BitmaskData const& bitmaskData, EnumData const& enumData)
-{
-  enterProtect(os, bitmaskData.protect);
-
-  // each Flags class is using on the class 'Flags' with the corresponding FlagBits enum as the template parameter
-  os << "  using " << bitmaskName << " = Flags<" << enumData.name << ", Vk" << bitmaskName << ">;" << std::endl;
-
-  std::stringstream allFlags;
-  for (size_t i = 0; i < enumData.values.size(); i++)
-  {
-    if (i != 0)
-    {
-      allFlags << " | ";
-    }
-    allFlags << "VkFlags(" << enumData.name << "::" << enumData.values[i].name << ")";
-  }
-
-  if (!enumData.values.empty())
-  {
-    const std::string templateString = R"(
-  VULKAN_HPP_INLINE ${bitmaskName} operator|( ${enumName} bit0, ${enumName} bit1 )
-  {
-    return ${bitmaskName}( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ${bitmaskName} operator~( ${enumName} bits )
-  {
-    return ~( ${bitmaskName}( bits ) );
-  }
-
-  template <> struct FlagTraits<${enumName}>
-  {
-    enum
-    {
-      allFlags = ${allFlags}
-    };
-  };
-)";
-    os << replaceWithMap(templateString, { { "bitmaskName", bitmaskName },{ "enumName", enumData.name },{ "allFlags", allFlags.str() } });
-  }
-
-  if (!bitmaskData.alias.empty())
-  {
-    os << std::endl
-      << "  using " << bitmaskData.alias << " = " << bitmaskName << ";" << std::endl;
-  }
-
-  leaveProtect(os, bitmaskData.protect);
-  os << std::endl;
-}
-
-void VulkanHppGenerator::writeTypeCommand(std::ostream & os, DependencyData const& dependencyData)
-{
-  assert(m_commands.find(dependencyData.name) != m_commands.end());
-  CommandData const& commandData = m_commands.find(dependencyData.name)->second;
-  if (commandData.className.empty())
-  {
-    if (commandData.fullName == "createInstance")
-    {
-      // special handling for createInstance, as we need to explicitly place the forward declarations and the deleter classes here
-#if !defined(NDEBUG)
-      auto deleterTypesIt = m_deleterTypes.find("");
-      assert((deleterTypesIt != m_deleterTypes.end()) && (deleterTypesIt->second.size() == 2));
-      assert(deleterTypesIt->second.find("Instance") != deleterTypesIt->second.end());
-#endif
-
-      writeUniqueTypes(os, std::make_pair<std::string, std::set<std::string>>("", { "Instance" }));
-      writeTypeCommand(os, "  ", commandData, false);
-    }
-    else
-    {
-      writeTypeCommand(os, "  ", commandData, false);
-    }
-    writeTypeCommand(os, "  ", commandData, true);
-    os << std::endl;
-  }
-}
-
-void VulkanHppGenerator::writeTypeCommand(std::ostream & os, std::string const& indentation, CommandData const& commandData, bool definition)
-{
-  enterProtect(os, commandData.protect);
-
-  bool isStructureChain = m_extendedStructs.find(commandData.enhancedReturnType) != m_extendedStructs.end();
-
-  // first create the standard version of the function
-  std::ostringstream standard;
-  writeFunction(standard, indentation, commandData, definition, false, false, false, false, false);
-
-  // then the enhanced version, composed by up to seven parts
-  std::ostringstream enhanced;
-  writeFunction(enhanced, indentation, commandData, definition, true, false, false, false, false);
-
-  if (commandData.enhancedReturnType.find("Allocator") != std::string::npos)
-  {
-    writeFunction(enhanced, indentation, commandData, definition, true, false, false, false, true);
-  }
-
-  if (isStructureChain)
-  {
-    writeFunction(enhanced, indentation, commandData, definition, true, false, false, true, false);
-  }
-
-  // then a singular version, if a sized vector would be returned
-  std::map<size_t, size_t>::const_iterator returnVector = commandData.vectorParams.find(commandData.returnParam);
-  bool singular = (returnVector != commandData.vectorParams.end()) &&
-                  (returnVector->second != INVALID_INDEX) &&
-                  (commandData.params[returnVector->first].pureType != "void") &&
-                  (commandData.params[returnVector->second].type.back() != '*');
-  if (singular)
-  {
-    writeFunction(enhanced, indentation, commandData, definition, true, true, false, false, false);
-  }
-
-  // special handling for createDevice and createInstance !
-  bool specialWriteUnique = (commandData.reducedName == "createDevice") || (commandData.reducedName == "createInstance");
-
-  // and then the same for the Unique* versions (a Deleter is available for the commandData's class, and the function starts with 'allocate' or 'create')
-  if (((m_deleters.find(commandData.className) != m_deleters.end()) || specialWriteUnique) && ((commandData.reducedName.substr(0, 8) == "allocate") || (commandData.reducedName.substr(0, 6) == "create")))
-  {
-    enhanced << "#ifndef VULKAN_HPP_NO_SMART_HANDLE" << std::endl;
-    writeFunction(enhanced, indentation, commandData, definition, true, false, true, false, false);
-
-    if (commandData.enhancedReturnType.find("Allocator") != std::string::npos)
-    {
-      writeFunction(enhanced, indentation, commandData, definition, true, false, true, false, true);
-    }
-
-    if (singular)
-    {
-      writeFunction(enhanced, indentation, commandData, definition, true, true, true, false, false);
-    }
-    enhanced << "#endif /*VULKAN_HPP_NO_SMART_HANDLE*/" << std::endl;
-  }
-
-  // and write one or both of them
-  writeStandardOrEnhanced(os, standard.str(), enhanced.str());
-
-  leaveProtect(os, commandData.protect);
-  os << std::endl;
-}
-
-void VulkanHppGenerator::writeTypeEnum(std::ostream & os, EnumData const& enumData)
-{
-  // a named enum per enum, listing all its values by setting them to the original Vulkan names
-  enterProtect(os, enumData.protect);
-  os << "  enum class " << enumData.name << std::endl
-    << "  {" << std::endl;
-  for (size_t i = 0; i<enumData.values.size(); i++)
-  {
-    os << "    " << enumData.values[i].name << " = " << enumData.values[i].value;
-    if (!enumData.values[i].alias.empty())
-    {
-      os << "," << std::endl
-        << "    " << enumData.values[i].alias << " = " << enumData.values[i].value;
-    }
-    if (i < enumData.values.size() - 1)
-    {
-      os << ",";
-    }
-    os << std::endl;
-  }
-  os << "  };" << std::endl;
-
-  leaveProtect(os, enumData.protect);
-  os << std::endl;
-}
-
-void VulkanHppGenerator::writeTypeHandle(std::ostream & os, DependencyData const& dependencyData, HandleData const& handleData)
-{
-  enterProtect(os, handleData.protect);
-
-  // check if there are any forward dependenices for this handle -> list them first
-  if (!dependencyData.forwardDependencies.empty())
-  {
-    os << "  // forward declarations" << std::endl;
-    for (std::set<std::string>::const_iterator it = dependencyData.forwardDependencies.begin(); it != dependencyData.forwardDependencies.end(); ++it)
-    {
-      assert(m_structs.find(*it) != m_structs.end());
-      os << "  struct " << *it << ";" << std::endl;
-    }
-    os << std::endl;
-  }
-
-  // then write any forward declaration of Deleters used by this handle
-  std::map<std::string, std::set<std::string>>::const_iterator deleterTypesIt = m_deleterTypes.find(dependencyData.name);
-  if (deleterTypesIt != m_deleterTypes.end())
-  {
-    writeUniqueTypes(os, *deleterTypesIt);
-  }
-  else if (dependencyData.name == "PhysicalDevice")
-  {
-    // special handling for class Device, as it's created from PhysicalDevice, but destroys itself
-    writeUniqueTypes(os, std::make_pair<std::string, std::set<std::string>>("", { "Device" }));
-  }
-
-  const std::string memberName = startLowerCase(dependencyData.name);
-  const std::string templateString =
-    R"(  class ${className}
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR ${className}()
-      : m_${memberName}(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR ${className}( std::nullptr_t )
-      : m_${memberName}(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT ${className}( Vk${className} ${memberName} )
-      : m_${memberName}( ${memberName} )
-    {}
 
 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    ${className} & operator=(Vk${className} ${memberName})
-    {
-      m_${memberName} = ${memberName};
-      return *this; 
-    }
+# define VULKAN_HPP_TYPESAFE_EXPLICIT
+#else
+# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
 #endif
 
-    ${className} & operator=( std::nullptr_t )
-    {
-      m_${memberName} = VK_NULL_HANDLE;
-      return *this;
-    }
+#if defined(_MSC_VER) && (_MSC_VER <= 1800)
+# define VULKAN_HPP_CONSTEXPR
+#else
+# define VULKAN_HPP_CONSTEXPR constexpr
+#endif
 
-    bool operator==( ${className} const & rhs ) const
-    {
-      return m_${memberName} == rhs.m_${memberName};
-    }
-
-    bool operator!=(${className} const & rhs ) const
-    {
-      return m_${memberName} != rhs.m_${memberName};
-    }
-
-    bool operator<(${className} const & rhs ) const
-    {
-      return m_${memberName} < rhs.m_${memberName};
-    }
-
-${commands}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator Vk${className}() const
-    {
-      return m_${memberName};
-    }
-
-    explicit operator bool() const
-    {
-      return m_${memberName} != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_${memberName} == VK_NULL_HANDLE;
-    }
-
-  private:
-    Vk${className} m_${memberName};
-  };
-
-  static_assert( sizeof( ${className} ) == sizeof( Vk${className} ), "handle and wrapper have different size!" );
+#if !defined(VULKAN_HPP_NAMESPACE)
+#define VULKAN_HPP_NAMESPACE vk
+#endif
 
+#define VULKAN_HPP_STRINGIFY2(text) #text
+#define VULKAN_HPP_STRINGIFY(text) VULKAN_HPP_STRINGIFY2(text)
+#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY(VULKAN_HPP_NAMESPACE)
 )";
 
-  std::ostringstream commands;
-  // now list all the commands that are mapped to members of this class
-  for (size_t i = 0; i < handleData.commands.size(); i++)
-  {
-    std::map<std::string, CommandData>::const_iterator cit = m_commands.find(handleData.commands[i]);
-    assert((cit != m_commands.end()) && !cit->second.className.empty());
-    writeTypeCommand(commands, "    ", cit->second, false);
-
-    // special handling for destroy functions which are not aliased.
-    if (!cit->second.isAlias && (((cit->second.fullName.substr(0, 7) == "destroy") && (cit->second.reducedName != "destroy")) || (cit->second.fullName.substr(0, 4) == "free")))
-    {
-      CommandData shortenedCommand = cit->second;
-      shortenedCommand.reducedName = (cit->second.fullName.substr(0, 7) == "destroy") ? "destroy" : "free";
-      writeTypeCommand(commands, "    ", shortenedCommand, false);
-    }
-  }
-
-  os << replaceWithMap(templateString, {
-    { "className", dependencyData.name },
-    { "memberName", memberName },
-    { "commands", commands.str() }
-  });
-
-  // and finally the commands, that are member functions of this handle
-  for (size_t i = 0; i < handleData.commands.size(); i++)
-  {
-    std::string commandName = handleData.commands[i];
-    std::map<std::string, CommandData>::const_iterator cit = m_commands.find(commandName);
-    assert((cit != m_commands.end()) && !cit->second.className.empty());
-    std::list<DependencyData>::const_iterator dep = std::find_if(m_dependencies.begin(), m_dependencies.end(), [commandName](DependencyData const& dd) { return dd.name == commandName; });
-    assert(dep != m_dependencies.end() && (dep->name == cit->second.fullName));
-    writeTypeCommand(os, "  ", cit->second, true);
-
-    // special handling for destroy functions
-    if (!cit->second.isAlias && (((cit->second.fullName.substr(0, 7) == "destroy") && (cit->second.reducedName != "destroy")) || (cit->second.fullName.substr(0, 4) == "free")))
-    {
-      CommandData shortenedCommand = cit->second;
-      shortenedCommand.reducedName = (cit->second.fullName.substr(0, 7) == "destroy") ? "destroy" : "free";
-      writeTypeCommand(os, "  ", shortenedCommand, true);
-    }
-  }
-
-  if (!handleData.alias.empty())
-  {
-    os << "  using " << handleData.alias << " = " << dependencyData.name << ";" << std::endl
-      << std::endl;
-  }
-
-  leaveProtect(os, handleData.protect);
-}
-
-void VulkanHppGenerator::writeTypes(std::ostream & os, std::map<std::string, std::string> const& defaultValues)
-{
-  assert(m_deleterTypes.find("") != m_deleterTypes.end());
-
-  for (std::list<DependencyData>::const_iterator it = m_dependencies.begin(); it != m_dependencies.end(); ++it)
-  {
-    switch (it->category)
-    {
-    case DependencyData::Category::BITMASK:
-      assert(m_bitmasks.find(it->name) != m_bitmasks.end());
-      writeTypeBitmask(os, it->name, m_bitmasks.find(it->name)->second, m_enums.find(generateEnumNameForFlags(it->name))->second);
-      break;
-    case DependencyData::Category::COMMAND:
-      writeTypeCommand(os, *it);
-      break;
-    case DependencyData::Category::ENUM:
-      assert(m_enums.find(it->name) != m_enums.end());
-      writeTypeEnum(os, m_enums.find(it->name)->second);
-      break;
-    case DependencyData::Category::FUNC_POINTER:
-    case DependencyData::Category::REQUIRED:
-      // skip FUNC_POINTER and REQUIRED, they just needed to be in the dependencies list to resolve dependencies
-      break;
-    case DependencyData::Category::HANDLE:
-      assert(m_handles.find(it->name) != m_handles.end());
-      writeTypeHandle(os, *it, m_handles.find(it->name)->second);
-      break;
-    case DependencyData::Category::SCALAR:
-      writeTypeScalar(os, *it);
-      break;
-    case DependencyData::Category::STRUCT:
-      writeTypeStruct(os, *it, defaultValues);
-      break;
-    case DependencyData::Category::UNION:
-      assert(m_structs.find(it->name) != m_structs.end());
-      writeTypeUnion(os, *it, defaultValues);
-      break;
-    default:
-      assert(false);
-      break;
-    }
-  }
-}
-
-void VulkanHppGenerator::writeTypeScalar(std::ostream & os, DependencyData const& dependencyData)
-{
-  assert(dependencyData.dependencies.size() == 1);
-  os << "  using " << dependencyData.name << " = " << *dependencyData.dependencies.begin() << ";" << std::endl
-    << std::endl;
-}
-
-void VulkanHppGenerator::writeTypeStruct(std::ostream & os, DependencyData const& dependencyData, std::map<std::string, std::string> const& defaultValues)
-{
-  std::map<std::string, StructData>::const_iterator it = m_structs.find(dependencyData.name);
-  assert(it != m_structs.end());
-
-  enterProtect(os, it->second.protect);
-  os << "  struct " << dependencyData.name << std::endl
-    << "  {" << std::endl;
-
-  // 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)
-  {
-    for (size_t i = 0; i < it->second.members.size(); i++)
-    {
-      writeStructSetter(os, dependencyData.name, it->second.members[i]);
-    }
-  }
-
-  // the implicit cast-operators to the native type
-  os << "    operator Vk" << dependencyData.name << " const&() const" << std::endl
-    << "    {" << std::endl
-    << "      return *reinterpret_cast<const Vk" << dependencyData.name << "*>(this);" << std::endl
-    << "    }" << std::endl
-    << std::endl
-    << "    operator Vk" << dependencyData.name << " &()" << std::endl
-    << "    {" << std::endl
-    << "      return *reinterpret_cast<Vk" << dependencyData.name << "*>(this);" << std::endl
-    << "    }" << std::endl
-    << std::endl;
-
-  // operator==() and operator!=()
-  // only structs without a union as a member can have a meaningfull == and != operation; we filter them out
-  if (!containsUnion(dependencyData.name, m_structs))
-  {
-    // two structs are compared by comparing each of the elements
-    os << "    bool operator==( " << dependencyData.name << " const& rhs ) const" << std::endl
-      << "    {" << std::endl
-      << "      return ";
-    for (size_t i = 0; i < it->second.members.size(); i++)
-    {
-      if (i != 0)
-      {
-        os << std::endl << "          && ";
-      }
-      if (!it->second.members[i].arraySize.empty())
-      {
-        os << "( memcmp( " << it->second.members[i].name << ", rhs." << it->second.members[i].name << ", " << it->second.members[i].arraySize << " * sizeof( " << it->second.members[i].type << " ) ) == 0 )";
-      }
-      else
-      {
-        os << "( " << it->second.members[i].name << " == rhs." << it->second.members[i].name << " )";
-      }
-    }
-    os << ";" << std::endl
-      << "    }" << std::endl
-      << std::endl
-      << "    bool operator!=( " << dependencyData.name << " const& rhs ) const" << std::endl
-      << "    {" << std::endl
-      << "      return !operator==( rhs );" << std::endl
-      << "    }" << std::endl
-      << std::endl;
-  }
-
-  // the member variables
-  for (size_t i = 0; i < it->second.members.size(); i++)
-  {
-    if (it->second.members[i].type == "StructureType")
-    {
-      assert((i == 0) && (it->second.members[i].name == "sType"));
-      if (!it->second.members[i].values.empty())
-      {
-        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 = " << nameIt->second << ";" << std::endl
-          << std::endl
-          << "  public:" << std::endl;
-      }
-      else
-      {
-        os << "    StructureType sType;" << std::endl;
-      }
-    }
-    else
-    {
-      os << "    " << it->second.members[i].type << " " << it->second.members[i].name;
-      if (it->second.members[i].name == "pNext")
-      {
-        os << " = nullptr";
-      }
-      else if (!it->second.members[i].arraySize.empty())
-      {
-        os << "[" << it->second.members[i].arraySize << "]";
-      }
-      os << ";" << std::endl;
-    }
-  }
-  os << "  };" << std::endl
-    << "  static_assert( sizeof( " << dependencyData.name << " ) == sizeof( Vk" << dependencyData.name << " ), \"struct and wrapper have different size!\" );" << std::endl;
-
-  if (!it->second.alias.empty())
-  {
-    os << std::endl
-      << "  using " << it->second.alias << " = " << dependencyData.name << ";" << std::endl;
-  }
-
-  leaveProtect(os, it->second.protect);
-  os << std::endl;
-}
-
-void VulkanHppGenerator::writeUniqueTypes(std::ostream &os, std::pair<std::string, std::set<std::string>> const& deleterTypes)
-{
-  os << "#ifndef VULKAN_HPP_NO_SMART_HANDLE" << std::endl;
-  if (!deleterTypes.first.empty())
-  {
-    os << "  class " << deleterTypes.first << ";" << std::endl;
-  }
-  os << std::endl;
-
-  for (auto const& dt : deleterTypes.second)
-  {
-    auto ddit = m_deleters.find(dt);
-    assert(ddit != m_deleters.end());
-
-    os << "  template <typename Dispatch> class UniqueHandleTraits<" << dt << ",Dispatch> {public: using deleter = " << (ddit->second.pool.empty() ? "Object" : "Pool") << ((ddit->second.call.substr(0, 4) == "free") ? "Free<" : "Destroy<") << (deleterTypes.first.empty() ? "NoParent" : deleterTypes.first) << (ddit->second.pool.empty() ? "" : ", " + ddit->second.pool) << ",Dispatch>; };\n";
-    os << "  using Unique" << dt << " = UniqueHandle<" << dt << ",DispatchLoaderStatic>;" << std::endl;
-  }
-  os << "#endif /*VULKAN_HPP_NO_SMART_HANDLE*/" << std::endl
-    << std::endl;
-}
-
-void VulkanHppGenerator::writeTypeUnion(std::ostream & os, DependencyData const& dependencyData, std::map<std::string, std::string> const& defaultValues)
-{
-  std::map<std::string, StructData>::const_iterator it = m_structs.find(dependencyData.name);
-  assert(it != m_structs.end());
-
-  std::ostringstream oss;
-  os << "  union " << dependencyData.name << std::endl
-    << "  {" << std::endl;
-
-  for (size_t i = 0; i<it->second.members.size(); i++)
-  {
-    // one constructor per union element
-    os << "    " << dependencyData.name << "( ";
-    if (it->second.members[i].arraySize.empty())
-    {
-      os << it->second.members[i].type << " ";
-    }
-    else
-    {
-      os << "const std::array<" << it->second.members[i].type << "," << it->second.members[i].arraySize << ">& ";
-    }
-    os << it->second.members[i].name << "_";
-
-    // just the very first constructor gets default arguments
-    if (i == 0)
-    {
-      std::map<std::string, std::string>::const_iterator defaultIt = defaultValues.find(it->second.members[i].pureType);
-      assert(defaultIt != defaultValues.end());
-      if (it->second.members[i].arraySize.empty())
-      {
-        os << " = " << defaultIt->second;
-      }
-      else
-      {
-        os << " = { {" << defaultIt->second << "} }";
-      }
-    }
-    os << " )" << std::endl
-      << "    {" << std::endl
-      << "      ";
-    if (it->second.members[i].arraySize.empty())
-    {
-      os << it->second.members[i].name << " = " << it->second.members[i].name << "_";
-    }
-    else
-    {
-      os << "memcpy( &" << it->second.members[i].name << ", " << it->second.members[i].name << "_.data(), " << it->second.members[i].arraySize << " * sizeof( " << it->second.members[i].type << " ) )";
-    }
-    os << ";" << std::endl
-      << "    }" << std::endl
-      << std::endl;
-  }
-
-  for (size_t i = 0; i<it->second.members.size(); i++)
-  {
-    // one setter per union element
-    assert(!it->second.returnedOnly);
-    writeStructSetter(os, dependencyData.name, it->second.members[i]);
-  }
-
-  // the implicit cast operators to the native type
-  os << "    operator Vk" << dependencyData.name << " const&() const" << std::endl
-    << "    {" << std::endl
-    << "      return *reinterpret_cast<const Vk" << dependencyData.name << "*>(this);" << std::endl
-    << "    }" << std::endl
-    << std::endl
-    << "    operator Vk" << dependencyData.name << " &()" << std::endl
-    << "    {" << std::endl
-    << "      return *reinterpret_cast<Vk" << dependencyData.name << "*>(this);" << std::endl
-    << "    }" << std::endl
-    << std::endl;
-
-  // the union member variables
-  // if there's at least one Vk... type in this union, check for unrestricted unions support
-  bool needsUnrestrictedUnions = false;
-  for (size_t i = 0; i < it->second.members.size() && !needsUnrestrictedUnions; i++)
-  {
-    needsUnrestrictedUnions = (m_vkTypes.find(it->second.members[i].type) != m_vkTypes.end());
-  }
-  if (needsUnrestrictedUnions)
-  {
-    os << "#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS" << std::endl;
-    for (size_t i = 0; i < it->second.members.size(); i++)
-    {
-      os << "    " << it->second.members[i].type << " " << it->second.members[i].name;
-      if (!it->second.members[i].arraySize.empty())
-      {
-        os << "[" << it->second.members[i].arraySize << "]";
-      }
-      os << ";" << std::endl;
-    }
-    os << "#else" << std::endl;
-  }
-  for (size_t i = 0; i < it->second.members.size(); i++)
-  {
-    os << "    ";
-    if (m_vkTypes.find(it->second.members[i].type) != m_vkTypes.end())
-    {
-      os << "Vk";
-    }
-    os << it->second.members[i].type << " " << it->second.members[i].name;
-    if (!it->second.members[i].arraySize.empty())
-    {
-      os << "[" << it->second.members[i].arraySize << "]";
-    }
-    os << ";" << std::endl;
-  }
-  if (needsUnrestrictedUnions)
-  {
-    os << "#endif  // VULKAN_HPP_HAS_UNRESTRICTED_UNIONS" << std::endl;
-  }
-  os << "  };" << std::endl
-    << std::endl;
-}
-
-#if !defined(NDEBUG)
-void VulkanHppGenerator::checkExtensionRequirements()
-{
-  for (auto const& ext : m_extensions)
-  {
-    for (auto const& req : ext.second.requires)
-    {
-      auto reqExt = m_extensions.find(req);
-      assert(reqExt != m_extensions.end());
-      assert(reqExt->second.protect.empty() || (reqExt->second.protect == ext.second.protect));
-    }
-  }
-}
-
-void VulkanHppGenerator::skipVendorID(tinyxml2::XMLElement const* element)
-{
-  std::map<std::string, std::string> attributes = getAttributes(element);
-  checkAttributes(attributes, element->GetLineNum(), { { "comment",{} },{ "id",{} },{ "name",{} } }, {});
-  checkElements(getChildElements(element), {});
-
-  VendorIDData vendorID;
-  for (auto const& attribute : attributes)
-  {
-    std::string name = attribute.first;
-    if (name == "comment")
-    {
-      vendorID.comment = attribute.second;
-    }
-    else if (name == "id")
-    {
-      vendorID.id = attribute.second;
-    }
-    else
-    {
-      assert(name == "name");
-      vendorID.name = attribute.second;
-    }
-  }
-  m_vendorIDs.push_back(vendorID);
-}
-
-void VulkanHppGenerator::skipVendorIDs(tinyxml2::XMLElement const* element)
-{
-  checkAttributes(getAttributes(element), element->GetLineNum(), { { "comment",{} } }, {});
-  std::vector<tinyxml2::XMLElement const*> children = getChildElements(element);
-  checkElements(children, { "vendorid" });
-
-  for (auto child : children)
-  {
-    skipVendorID(child);
-  }
-}
+  static const std::string exceptions = R"(
+#if defined(_MSC_VER) && (_MSC_VER == 1800)
+# define noexcept _NOEXCEPT
 #endif
 
-void VulkanHppGenerator::EnumData::addEnumValue(std::string const &enumName, std::string const& tag, std::map<std::string, std::string> & nameMap)
-{
-  EnumValueData evd;
-  evd.name = createEnumValueName(enumName, prefix, postfix, bitmask, tag);
-  evd.value = enumName;
+  class ErrorCategoryImpl : public std::error_category
+  {
+    public:
+    virtual const char* name() const noexcept override { return VULKAN_HPP_NAMESPACE_STRING"::Result"; }
+    virtual std::string message(int ev) const override { return to_string(static_cast<Result>(ev)); }
+  };
 
-  auto it = std::find_if(values.begin(), values.end(), [&evd](EnumValueData const& _evd) { return _evd.name == evd.name; });
-  if (it == values.end())
+  class Error
   {
-    values.push_back(evd);
-    assert(nameMap.find(enumName) == nameMap.end());
-    nameMap[enumName] = this->name + "::" + evd.name;
-  }
-  else
+    public:
+    virtual ~Error() = default;
+
+    virtual const char* what() const noexcept = 0;
+  };
+
+  class LogicError : public Error, public std::logic_error
   {
-    assert(it->value == evd.value);
+    public:
+    explicit LogicError( const std::string& what )
+      : Error(), std::logic_error(what) {}
+    explicit LogicError( char const * what )
+      : Error(), std::logic_error(what) {}
+    virtual ~LogicError() = default;
+
+    virtual const char* what() const noexcept { return std::logic_error::what(); }
+  };
+
+  class SystemError : public Error, public std::system_error
+  {
+    public:
+    SystemError( std::error_code ec )
+      : Error(), std::system_error(ec) {}
+    SystemError( std::error_code ec, std::string const& what )
+      : Error(), std::system_error(ec, what) {}
+    SystemError( std::error_code ec, char const * what )
+      : Error(), std::system_error(ec, what) {}
+    SystemError( int ev, std::error_category const& ecat )
+      : Error(), std::system_error(ev, ecat) {}
+    SystemError( int ev, std::error_category const& ecat, std::string const& what)
+      : Error(), std::system_error(ev, ecat, what) {}
+    SystemError( int ev, std::error_category const& ecat, char const * what)
+      : Error(), std::system_error(ev, ecat, what) {}
+    virtual ~SystemError() = default;
+
+    virtual const char* what() const noexcept { return std::system_error::what(); }
+  };
+
+#if defined(_MSC_VER) && (_MSC_VER == 1800)
+# undef noexcept
+#endif
+
+  VULKAN_HPP_INLINE const std::error_category& errorCategory()
+  {
+    static ErrorCategoryImpl instance;
+    return instance;
   }
+
+  VULKAN_HPP_INLINE std::error_code make_error_code(Result e)
+  {
+    return std::error_code(static_cast<int>(e), errorCategory());
+  }
+
+  VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e)
+  {
+    return std::error_condition(static_cast<int>(e), errorCategory());
+  }
+)";
+
+  static const std::string includes = R"(
+#ifndef VULKAN_HPP
+#define VULKAN_HPP
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <initializer_list>
+#include <string>
+#include <system_error>
+#include <tuple>
+#include <type_traits>
+#include <vulkan/vulkan.h>
+
+#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+# include <memory>
+# include <vector>
+#endif
+
+#if !defined(VULKAN_HPP_ASSERT)
+# include <cassert>
+# define VULKAN_HPP_ASSERT   assert
+#endif
+)";
+
+  static const std::string is_error_code_enum = R"(
+namespace std
+{
+  template <>
+  struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
+  {};
 }
+)";
 
-void VulkanHppGenerator::writeDelegationClassStatic(std::ostream &os)
-{
-  os << "class DispatchLoaderStatic" << std::endl
-     << "{"                    << std::endl
-     << "public:\n";
+  static const std::string structResultValue = R"(
+  template <typename T> void ignore(T const&) {}
 
-  for (auto command : m_commands)
+  template <typename T>
+  struct ResultValue
   {
-    enterProtect(os, command.second.protect);
-    os << "  " << command.second.unchangedReturnType << " vk" << startUpperCase(command.second.fullName) << "( ";
-    bool first = true;
-    for (auto param : command.second.params)
-    {
-      if (!first) {
-        os << ", ";
-      }
-      os << param.unchangedType << " " << param.name;
-      if (!param.arraySize.empty())
-      {
-        os << "[" << param.arraySize << "]";
-      }
-      first = false;
-    }
-    os << "  ) const\n"
-      << "  {\n"
-      << "    return ::vk" << startUpperCase(command.second.fullName) << "( ";
-    first = true;
-    for (auto param : command.second.params)
-    {
-      if (!first) {
-        os << ", ";
-      }
-      os << param.name;
-      first = false;
-    }
-    os << ");\n";
-    os << "  }\n";
-    leaveProtect(os, command.second.protect);
-  }
-  os << "};\n";
-}
+    ResultValue( Result r, T & v )
+      : result( r )
+      , value( v )
+    {}
 
-void VulkanHppGenerator::writeDelegationClassDynamic(std::ostream &os)
-{
-  os << "  class DispatchLoaderDynamic" << std::endl
-     << "  {" << std::endl
-     << "  public:" << std::endl;
+    ResultValue( Result r, T && v )
+      : result( r )
+      , value( std::move( v ) )
+    {}
 
-  for (auto command : m_commands)
+    Result  result;
+    T       value;
+
+    operator std::tuple<Result&, T&>() { return std::tuple<Result&, T&>(result, value); }
+  };
+
+  template <typename T>
+  struct ResultValueType
   {
-    enterProtect(os, command.second.protect);
-    os << "    PFN_vk" << startUpperCase(command.second.fullName) << " vk" << startUpperCase(command.second.fullName) << " = 0;" << std::endl;
-    leaveProtect(os, command.second.protect);
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    typedef ResultValue<T>  type;
+#else
+    typedef T               type;
+#endif
+  };
+
+  template <>
+  struct ResultValueType<void>
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    typedef Result type;
+#else
+    typedef void   type;
+#endif
+  };
+
+  VULKAN_HPP_INLINE ResultValueType<void>::type createResultValue( Result result, char const * message )
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    ignore(message);
+    VULKAN_HPP_ASSERT( result == Result::eSuccess );
+    return result;
+#else
+    if ( result != Result::eSuccess )
+    {
+      throwResultException( result, message );
+    }
+#endif
   }
 
-  // write initialization function to fetch function pointers
-  os << "  public:" << std::endl
-     << "    DispatchLoaderDynamic(Instance instance = Instance(), Device device = Device())" << std::endl
-     << "    {" << std::endl
-     << "      if (instance)" << std::endl
-     << "      {" << std::endl
-     << "        init(instance, device);" << std::endl
-     << "      }" << std::endl
-     << "    }" << std::endl << std::endl
-     << "    void init(Instance instance, Device device = Device())" << std::endl
-     << "    {" << std::endl;
-
-  for (auto command : m_commands)
+  template <typename T>
+  VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValue( Result result, T & data, char const * message )
   {
-    enterProtect(os, command.second.protect);
-    if (!command.second.params.empty() 
-      && m_handles.find(command.second.params[0].type) != m_handles.end()
-      && command.second.params[0].type != "Instance"
-      && command.second.params[0].type != "PhysicalDevice")
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    ignore(message);
+    VULKAN_HPP_ASSERT( result == Result::eSuccess );
+    return ResultValue<T>( result, std::move( data ) );
+#else
+    if ( result != Result::eSuccess )
     {
-      os << "      vk" << startUpperCase(command.second.fullName) << " = PFN_vk" << startUpperCase(command.second.fullName) 
-        << "(device ? device.getProcAddr( \"vk" << startUpperCase(command.second.fullName) << "\") : instance.getProcAddr( \"vk" << startUpperCase(command.second.fullName) << "\"));" << std::endl;
+      throwResultException( result, message );
     }
-    else {
-      os << "      vk" << startUpperCase(command.second.fullName) << " = PFN_vk" << startUpperCase(command.second.fullName) << "(instance.getProcAddr( \"vk" << startUpperCase(command.second.fullName) << "\"));" << std::endl;
-    }
-    leaveProtect(os, command.second.protect);
+    return std::move( data );
+#endif
   }
-  os << "    }" << std::endl;
-  os << "  };\n";
-}
 
-int main( int argc, char **argv )
-{
+  VULKAN_HPP_INLINE Result createResultValue( Result result, char const * message, std::initializer_list<Result> successCodes )
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    ignore(message);
+    VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
+#else
+    if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+    {
+      throwResultException( result, message );
+    }
+#endif
+    return result;
+  }
+
+  template <typename T>
+  VULKAN_HPP_INLINE ResultValue<T> createResultValue( Result result, T & data, char const * message, std::initializer_list<Result> successCodes )
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    ignore(message);
+    VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
+#else
+    if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+    {
+      throwResultException( result, message );
+    }
+#endif
+    return ResultValue<T>( result, data );
+  }
+
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename T, typename D>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<T,D>>::type createResultValue( Result result, T & data, char const * message, typename UniqueHandleTraits<T,D>::deleter const& deleter )
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    ignore(message);
+    VULKAN_HPP_ASSERT( result == Result::eSuccess );
+    return ResultValue<UniqueHandle<T,D>>( result, UniqueHandle<T,D>(data, deleter) );
+#else
+    if ( result != Result::eSuccess )
+    {
+      throwResultException( result, message );
+    }
+    return UniqueHandle<T,D>(data, deleter);
+#endif
+  }
+#endif
+)";
+
   try {
     tinyxml2::XMLDocument doc;
 
@@ -5225,8 +5059,6 @@ int main( int argc, char **argv )
 
     VulkanHppGenerator generator;
 
-    bool foundLicense = false;
-
     tinyxml2::XMLElement const* registryElement = doc.FirstChildElement();
     checkAttributes(getAttributes(registryElement), registryElement->GetLineNum(), {}, {});
     assert(strcmp(registryElement->Value(), "registry") == 0);
@@ -5243,12 +5075,7 @@ int main( int argc, char **argv )
       }
       else if (value == "comment")
       {
-        if (!foundLicense)
-        {
-          // get the vulkan license header and skip any leading spaces
-          generator.readComment(child);
-          foundLicense = true;
-        }
+        generator.readComment(child);
       }
       else if (value == "enums")
       {
@@ -5274,12 +5101,6 @@ int main( int argc, char **argv )
       {
         generator.readTypes(child);
       }
-      else if (value == "vendorids")
-      {
-#if !defined(NDEBUG)
-        generator.skipVendorIDs(child);
-#endif
-      }
       else
       {
         std::stringstream lineNumber;
@@ -5289,99 +5110,60 @@ int main( int argc, char **argv )
     }
 
     generator.checkCorrectness();
-    generator.sortDependencies();
 
-#if !defined(NDEBUG)
-    generator.checkExtensionRequirements();
-#endif
-
-    std::map<std::string, std::string> defaultValues = generator.createDefaults();
+    std::set<std::string> forwardDeclarations = generator.gatherForwardDeclarations();
 
     std::ofstream ofs(VULKAN_HPP_FILE);
     ofs << generator.getVulkanLicenseHeader() << std::endl
-      << R"(
-#ifndef VULKAN_HPP
-#define VULKAN_HPP
-
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <initializer_list>
-#include <string>
-#include <system_error>
-#include <tuple>
-#include <type_traits>
-#include <vulkan/vulkan.h>
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-# include <memory>
-# include <vector>
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#if !defined(VULKAN_HPP_ASSERT)
-# include <cassert>
-# define VULKAN_HPP_ASSERT   assert
-#endif
-
-// <tuple> includes <sys/sysmacros.h> through some other header
-// this results in major(x) being resolved to gnu_dev_major(x)
-// which is an expression in a constructor initializer list.
-#if defined(major)
-  #undef major
-#endif
-#if defined(minor)
-  #undef minor
-#endif
-
-// Windows defines MemoryBarrier which is deprecated and collides
-// with the vk::MemoryBarrier struct.
-#ifdef MemoryBarrier
-  #undef MemoryBarrier
-#endif
-
-)";
-
-    writeVersionCheck(ofs, generator.getVersion());
-    writeTypesafeCheck(ofs, generator.getTypesafeCheck());
-    ofs << versionCheckHeader
-      << inlineHeader
-      << explicitHeader
-      << constExprHeader
+      << includes
       << std::endl
-      << vkNamespace
-      << flagsHeader
-      << optionalClassHeader
-      << arrayProxyHeader
-      << uniqueHandleHeader
-      << structureChainHeader;
-
-    // first of all, write out vk::Result and the exception handling stuff
-    generator.writeResultEnum(ofs);
-
+      << "static_assert( VK_HEADER_VERSION == " << generator.getVersion() << " , \"Wrong VK_HEADER_VERSION!\" );" << std::endl
+      << std::endl
+      << "// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default." << std::endl
+      << "// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION" << std::endl
+      << generator.getTypesafeCheck() << std::endl
+      << "# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )" << std::endl
+      << "#  define VULKAN_HPP_TYPESAFE_CONVERSION" << std::endl
+      << "# endif" << std::endl
+      << "#endif" << std::endl
+      << defines
+      << std::endl
+      << "namespace VULKAN_HPP_NAMESPACE" << std::endl
+      << "{"
+      << classArrayProxy
+      << classFlags
+      << classOptional
+      << classStructureChain
+      << classUniqueHandle;
+    generator.writeDispatchLoaderStatic(ofs);
+    ofs << classObjectDestroy
+      << classObjectFree
+      << classPoolFree
+      << std::endl;
+    generator.writeBaseTypes(ofs);
+    generator.writeEnums(ofs);
+    generator.writeBitmasks(ofs);
     ofs << "} // namespace VULKAN_HPP_NAMESPACE" << std::endl
-      << std::endl
-      << "namespace std" << std::endl
-      << "{" << std::endl
-      << "  template <>" << std::endl
-      << "  struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type" << std::endl
-      << "  {};" << std::endl
-      << "}" << std::endl
+      << is_error_code_enum
       << std::endl
       << "namespace VULKAN_HPP_NAMESPACE" << std::endl
       << "{" << std::endl
-      << resultValueHeader
-      << createResultValueHeader;
-    generator.writeDelegationClassStatic(ofs);
-    ofs << deleterClassString;
+      << "#ifndef VULKAN_HPP_NO_EXCEPTIONS"
+      << exceptions;
+    generator.writeResultExceptions(ofs);
+    generator.writeThrowExceptions(ofs);
+    ofs << "#endif" << std::endl;
+    ofs << structResultValue;
+    generator.writeForwardDeclarations(ofs, forwardDeclarations);
+    generator.writeHandles(ofs);
+    generator.writeStructs(ofs);
+    generator.writeHandlesCommandDefintions(ofs);
 
-    generator.writeTypes(ofs, defaultValues);
     generator.writeStructureChainValidation(ofs);
-    generator.writeToStringFunctions(ofs);
 
-    generator.writeDelegationClassDynamic(ofs);
+    generator.writeDispatchLoaderDynamic(ofs);
 
     ofs << "} // namespace VULKAN_HPP_NAMESPACE" << std::endl
-      << std::endl
       << "#endif" << std::endl;
   }
   catch (std::exception const& e)
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index b078ee9..0f10199 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -1,4 +1,4 @@
-// Copyright(c) 2015-2016, NVIDIA CORPORATION. All rights reserved.
+// Copyright(c) 2015-2019, NVIDIA CORPORATION. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,11 +14,9 @@
 
 #pragma once
 
-#include <list>
 #include <map>
 #include <iostream>
 #include <set>
-#include <string>
 #include <vector>
 #include <tinyxml2.h>
 
@@ -31,7 +29,7 @@ class VulkanHppGenerator
     }
 
     void checkCorrectness();
-    std::map<std::string, std::string> createDefaults();
+    std::set<std::string> gatherForwardDeclarations();
     std::string const& getTypesafeCheck() const;
     std::string const& getVersion() const;
     std::string const& getVulkanLicenseHeader() const;
@@ -43,58 +41,50 @@ class VulkanHppGenerator
     void readPlatforms(tinyxml2::XMLElement const* element);
     void readTags(tinyxml2::XMLElement const* element);
     void readTypes(tinyxml2::XMLElement const* element);
-    void sortDependencies();
-    void writeResultEnum(std::ostream & os);
+    void writeBaseTypes(std::ostream & os) const;
+    void writeBitmasks(std::ostream & os) const;
+    void writeDispatchLoaderDynamic(std::ostream &os); // use vkGet*ProcAddress to get function pointers
+    void writeDispatchLoaderStatic(std::ostream &os);  // use exported symbols from loader
+    void writeEnums(std::ostream & os) const;
+    void writeForwardDeclarations(std::ostream & os, std::set<std::string> const& forwardDeclarations) const;
+    void writeHandles(std::ostream & os) const;
+    void writeHandlesCommandDefintions(std::ostream & os) const;
+    void writeResultExceptions(std::ostream & os) const;
+    void writeStructs(std::ostream & os) const;
     void writeStructureChainValidation(std::ostream & os);
-    void writeToStringFunctions(std::ostream & os);
-    void writeTypes(std::ostream & os, std::map<std::string, std::string> const& defaultValues);
-    void writeDelegationClassStatic(std::ostream &os);  // use exported symbols from loader
-    void writeDelegationClassDynamic(std::ostream &os); // use vkGet*ProcAddress to get function pointers
-#if !defined(NDEBUG)
-    void checkExtensionRequirements();
-    void skipVendorIDs(tinyxml2::XMLElement const* element);
-#endif
+    void writeThrowExceptions(std::ostream& os) const;
 
   private:
     struct BitmaskData
     {
-      std::string protect;
-      std::string alias;
-    };
-
-    struct DependencyData
-    {
-      enum class Category
-      {
-        BITMASK,
-        COMMAND,
-        ENUM,
-        FUNC_POINTER,
-        HANDLE,
-        REQUIRED,
-        SCALAR,
-        STRUCT,
-        UNION
-      };
-
-      DependencyData(Category c, std::string const& n)
-        : category(c)
-        , name(n)
+      BitmaskData(std::string const& r)
+        : requires(r)
       {}
 
-      Category              category;
-      std::string           name;
-      std::set<std::string> dependencies;
-      std::set<std::string> forwardDependencies;
+      std::string requires;   // original vulkan name: VK*FlagBits
+      std::string platform;
+      std::string alias;      // original vulkan name
+    };
+
+    struct TypeData
+    {
+      std::string compose() const;
+
+      bool operator==(TypeData const& rhs) const
+      {
+        return (prefix == rhs.prefix) && (type == rhs.type) && (postfix == rhs.postfix);
+      }
+
+      std::string prefix;
+      std::string type;
+      std::string postfix;
     };
 
     struct ParamData
     {
-      std::string type;
-      std::string unchangedType;
+      TypeData    type;
       std::string name;
       std::string arraySize;
-      std::string pureType;
       std::string len;
       bool        optional;
     };
@@ -102,83 +92,45 @@ class VulkanHppGenerator
     struct CommandData
     {
       CommandData()
-        : returnParam(size_t(~0))
-        , templateParam(size_t(~0))
-        , twoStep(false)
-        , isAlias(false)
+        : isAlias(false)
       {}
 
-      std::string               className;
-      std::string               enhancedReturnType;
-      std::string               fullName;
       std::vector<ParamData>    params;
-      std::string               protect;
-      std::string               reducedName;
-      size_t                    returnParam;
+      std::string               platform;
       std::string               returnType;
-      std::string               unchangedReturnType;
-      std::set<size_t>          skippedParams;
       std::vector<std::string>  successCodes;
-      size_t                    templateParam;
-      std::map<size_t, size_t>  vectorParams;
-      bool                      twoStep;
       bool                      isAlias;
     };
 
-    struct DeleterData
-    {
-      std::string pool;
-      std::string call;
-    };
-
-    struct EnumValueData
-    {
-      std::string name;
-      std::string value;
-      std::string alias;
-    };
-
     struct EnumData
     {
-      EnumData(std::string const& n, bool b = false)
-        : name(n)
-        , bitmask(b)
-      {}
+      void addAlias(std::string const& valueName, std::string const& aliasName, bool bitmask, std::string const& prefix, std::string const& postfix, std::string const& tag);
+      void addEnumValue(std::string const& valueName, bool bitmask, std::string const& prefix, std::string const& postfix, std::string const& tag);
 
-      void addEnumValue(std::string const& name, std::string const& tag, std::map<std::string, std::string> & nameMap);
-
-      std::string                 name;
-      std::string                 prefix;
-      std::string                 postfix;
-      std::vector<EnumValueData>  values;
-      std::string                 protect;
-      bool                        bitmask;
+      std::vector<std::pair<std::string, std::string>>  values;   // pairs of vulkan enum value and corresponding vk::-namespace enum value
+      std::vector<std::pair<std::string, std::string>>  aliases;  // pairs of vulkan enum value and corresponding vk::-namespace enum value
     };
 
     struct HandleData
     {
-      std::vector<std::string>  commands;
-      std::string               protect;
-      std::string               alias;
+      std::string                         alias;
+      std::map<std::string, CommandData>  commands;
+      std::string                         deleteCommand;
+      std::string                         deletePool;
+      std::set<std::string>               childrenHandles;
     };
 
     struct MemberData
     {
-      std::string type;
+      TypeData    type;
       std::string name;
       std::string arraySize;
-      std::string pureType;
       std::string values;
     };
 
-    struct ScalarData
+    struct StructureData
     {
-      std::string protect;
-    };
-
-    struct StructData
-    {
-      StructData()
+      StructureData()
         : returnedOnly(false)
       {}
 
@@ -191,129 +143,104 @@ class VulkanHppGenerator
       std::string               subStruct;
     };
 
-#if !defined(NDEBUG)
-    struct ExtensionData
-    {
-      std::string               protect;
-      std::vector<std::string>  requires;
-    };
-
-    struct VendorIDData
-    {
-      std::string name;
-      std::string id;
-      std::string comment;
-    };
-#endif
-
   private:
-    template <typename T> void checkAlias(std::map<std::string, T> const& data, std::string const& name, int line);
-    bool containsUnion(std::string const& type, std::map<std::string, StructData> const& structs);
-    void determineEnhancedReturnType(CommandData & commandData);
-    void determineReducedName(CommandData & commandData);
-    void determineReturnParam(CommandData & commandData);
-    void determineSkippedParams(CommandData & commandData);
-    void determineTemplateParam(CommandData & commandData);
-    void determineVectorParams(CommandData & commandData);
-    std::string generateCall(CommandData const& commandData, bool firstCall, bool singular);
-    bool isSubStruct(std::pair<std::string, StructData> const& nsd, std::string const& name, StructData const& structData);
-    void linkCommandToHandle(CommandData & commandData);
-    bool readCommandParam(tinyxml2::XMLElement const* element, std::set<std::string> & dependencies, std::vector<ParamData> & params);
+    bool containsUnion(std::string const& type) const;
+    std::string defaultValue(std::string const& type) const;
+    std::string determineEnhancedReturnType(CommandData const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool isStructureChain) const;
+    size_t determineReturnParamIndex(CommandData const& commandData, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep) const;
+    std::string determineSubStruct(std::pair<std::string, StructureData> const& structure) const;
+    size_t determineTemplateParamIndex(std::vector<ParamData> const& params, std::map<size_t, size_t> const& vectorParamIndices) const;
+    std::map<size_t, size_t> determineVectorParamIndices(std::vector<ParamData> const& params) const;
+    std::string generateCall(std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool firstCall, bool singular) const;
+    bool isTwoStepAlgorithm(std::vector<ParamData> const& params) const;
+    void linkCommandToHandle(std::string const& name, CommandData const& commandData);
+    void readBaseType(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes);
+    void readBitmask(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes);
+    void readBitmaskAlias(int lineNum, std::string const& alias, std::map<std::string, std::string> const& attributes, std::vector<tinyxml2::XMLElement const*> const& children);
+    void readCommand(tinyxml2::XMLElement const* element);
+    void readCommandAlias(int lineNum, std::string const& alias, std::map<std::string, std::string> const& attributes, std::vector<tinyxml2::XMLElement const*> const& children);
+    ParamData readCommandParam(tinyxml2::XMLElement const* element);
     tinyxml2::XMLNode const* readCommandParamType(tinyxml2::XMLNode const* node, ParamData& param);
-    void readCommandsCommand(tinyxml2::XMLElement const* element);
-    void readCommandProto(tinyxml2::XMLElement const* element, std::string & returnType, std::string & unchangedReturnType, std::string & fullName);
-    void readDisabledExtensionRequire(tinyxml2::XMLElement const* element);
-    void readEnumsEnum(tinyxml2::XMLElement const* element, EnumData & enumData, std::string const& tag);
-    void readEnumsConstant(tinyxml2::XMLElement const* element);
-    void readExtensionCommand(tinyxml2::XMLElement const* element, std::string const& protect);
-    void readExtensionEnum(tinyxml2::XMLElement const* element, std::string const& tag);
-    void readExtensionRequire(tinyxml2::XMLElement const* element, std::string const& protect, std::string const& tag);
-    void readExtensionsExtension(tinyxml2::XMLElement const* element);
-    void readExtensionType(tinyxml2::XMLElement const* element, std::string const& protect);
+    std::string readCommandProto(tinyxml2::XMLElement const* element, std::string & returnType);
+    std::vector<std::string> readCommandSuccessCodes(std::map<std::string, std::string> const& attributes);
+    void readDefine(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes);
+    void readEnum(tinyxml2::XMLElement const* element, EnumData & enumData, bool bitmask, std::string const& prefix, std::string const& postfix);
+    void readExtension(tinyxml2::XMLElement const* element);
+    void readExtensionDisabled(std::vector<tinyxml2::XMLElement const*> const& children);
+    void readExtensionDisabledRequire(tinyxml2::XMLElement const* element);
+    void readExtensionRequire(tinyxml2::XMLElement const* element, std::string const& platform, std::string const& tag);
+    void readExtensionRequireCommand(tinyxml2::XMLElement const* element, std::string const& platform);
+    void readExtensionRequireEnum(tinyxml2::XMLElement const* element, std::string const& tag);
+    void readExtensionRequireType(tinyxml2::XMLElement const* element, std::string const& platform);
     void readFeatureRequire(tinyxml2::XMLElement const* element);
     void readFeatureRequireEnum(tinyxml2::XMLElement const* element);
+    void readFuncpointer(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes);
+    void readHandle(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes);
     void readPlatform(tinyxml2::XMLElement const* element);
+    void readStruct(tinyxml2::XMLElement const* element, bool isUnion, std::map<std::string, std::string> const& attributes);
+    void readStructAlias(int lineNum, std::string const& name, std::string const& alias, std::map<std::string, std::string> const& attributes);
+    MemberData readStructMember(tinyxml2::XMLElement const* element);
+    std::vector<MemberData> readStructMembers(std::vector<tinyxml2::XMLElement const*> const& children);
     void readTag(tinyxml2::XMLElement const* element);
     void readType(tinyxml2::XMLElement const* element);
-    void readTypeBasetype(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes);
-    void readTypeBitmask(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes);
-    void readTypeDefine(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes);
-    void readTypeFuncpointer(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes);
-    void readTypeHandle(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes);
-    void readTypeName(tinyxml2::XMLElement const* element, std::map<std::string, std::string> const& attributes);
-    void readTypeStruct(tinyxml2::XMLElement const* element, bool isUnion, std::map<std::string, std::string> const& attributes);
-    void readTypeStructMember(tinyxml2::XMLElement const* element, StructData & structData);
-    void registerDeleter(CommandData const& commandData);
-    void setDefault(std::string const& name, std::map<std::string, std::string> & defaultValues, EnumData const& enumData);
-    void writeArguments(std::ostream & os, CommandData const& commandData, bool firstCall, bool singular, size_t from, size_t to);
-    void writeBitmaskToString(std::ostream & os, std::string const& flagsName, EnumData const &enumData);
-    void writeCall(std::ostream & os, CommandData const& commandData, bool firstCall, bool singular);
-    void writeCallCountParameter(std::ostream & os, CommandData const& commandData, bool singular, std::map<size_t, size_t>::const_iterator it);
-    void writeCallPlainTypeParameter(std::ostream & os, ParamData const& paramData);
-    void writeCallVectorParameter(std::ostream & os, CommandData const& commandData, bool firstCall, bool singular, std::map<size_t, size_t>::const_iterator it);
-    void writeCallVulkanTypeParameter(std::ostream & os, ParamData const& paramData);
-    void writeEnumsToString(std::ostream & os, EnumData const& enumData);
-    void writeExceptionsForEnum(std::ostream & os, EnumData const& enumData);
-    void writeFunction(std::ostream & os, std::string const& indentation, CommandData const& commandData, bool definition, bool enhanced, bool singular, bool unique, bool isStructureChain, bool withAllocator);
-    void writeFunctionBodyEnhanced(std::ostream & os, std::string const& indentation, CommandData const& commandData, bool singular, bool unique, bool isStructureChain, bool withAllocator);
-    void writeFunctionBodyEnhanced(std::ostream & os, std::string const& templateString, std::string const& indentation, CommandData const& commandData, bool singular);
-    void writeFunctionBodyTwoStep(std::ostream & os, std::string const &templateString, std::string const& indentation, std::string const& returnName, std::string const& sizeName, CommandData const& commandData);
-    std::string writeFunctionBodyEnhancedLocalReturnVariable(std::ostream & os, std::string const& indentation, CommandData const& commandData, bool singular, bool isStructureChain, bool withAllocator);
-    void writeFunctionBodyEnhancedCall(std::ostream &os, std::string const& indentation, CommandData const& commandData, bool singular);
-    void writeFunctionBodyEnhancedCallResult(std::ostream &os, std::string const& indentation, CommandData const& commandData, bool singular);
-    void writeFunctionBodyEnhancedCallTwoStep(std::ostream & os, std::string const& indentation, std::string const& returnName, std::string const& sizeName, CommandData const& commandData);
-    void writeFunctionBodyEnhancedCallTwoStepIterate(std::ostream & os, std::string const& indentation, std::string const& returnName, std::string const& sizeName, CommandData const& commandData);
-    void writeFunctionBodyEnhancedCallTwoStepChecked(std::ostream & os, std::string const& indentation, std::string const& returnName, std::string const& sizeName, CommandData const& commandData);
-    void writeFunctionBodyEnhancedLocalCountVariable(std::ostream & os, std::string const& indentation, CommandData const& commandData);
-    void writeFunctionBodyEnhancedMultiVectorSizeCheck(std::ostream & os, std::string const& indentation, CommandData const& commandData);
-    void writeFunctionBodyEnhancedReturnResultValue(std::ostream & os, std::string const& indentation, std::string const& returnName, CommandData const& commandData, bool singular, bool unique);
-    void writeFunctionBodyStandard(std::ostream & os, std::string const& indentation, CommandData const& commandData);
-    void writeFunctionHeaderArguments(std::ostream & os, CommandData const& commandData, bool enhanced, bool singular, bool withDefaults, bool withAllocator);
-    void writeFunctionHeaderArgumentsEnhanced(std::ostream & os, CommandData const& commandData, bool singular, bool withDefaults, bool withAllocator);
-    void writeFunctionHeaderArgumentsStandard(std::ostream & os, CommandData const& commandData, bool withDefaults);
-    void writeFunctionHeaderReturnType(std::ostream & os, CommandData const& commandData, bool enhanced, bool singular, bool unique, bool isStructureChain);
-    void writeFunctionHeaderTemplate(std::ostream & os, std::string const& indentation, CommandData const& commandData, bool enhanced, bool singular, bool unique, bool withDefault, bool isStructureChain);
-    void writeIndentation(std::ostream & os, size_t indentLength);
-    void writeStructConstructor(std::ostream & os, std::string const& name, StructData const& structData, std::map<std::string, std::string> const& defaultValues);
-    bool writeStructConstructorArgument(std::ostream & os, bool listedArgument, size_t indentLength, MemberData const& memberData, std::map<std::string, std::string> const& defaultValues);
-    void writeStructSetter(std::ostream & os, std::string const& structureName, MemberData const& memberData);
-    void writeStructureChainValidation(std::ostream & os, DependencyData const& dependencyData);
-    void writeThrowExceptions(std::ostream& os, EnumData const& enumData);
-    void writeTypeBitmask(std::ostream & os, std::string const& flagsName, BitmaskData const& bitmaskData, EnumData const& enumData);
-    void writeTypeCommand(std::ostream & os, DependencyData const& dependencyData);
-    void writeTypeCommand(std::ostream &os, std::string const& indentation, CommandData const& commandData, bool definition);
-    void writeTypeEnum(std::ostream & os, EnumData const& enumData);
-    void writeTypeHandle(std::ostream & os, DependencyData const& dependencyData, HandleData const& handle);
-    void writeTypeScalar(std::ostream & os, DependencyData const& dependencyData);
-    void writeTypeStruct(std::ostream & os, DependencyData const& dependencyData, std::map<std::string, std::string> const& defaultValues);
-    void writeTypeUnion(std::ostream & os, DependencyData const& dependencyData, std::map<std::string, std::string> const& defaultValues);
-    void writeUniqueTypes(std::ostream &os, std::pair<std::string, std::set<std::string>> const& deleterTypes);
-#if !defined(NDEBUG)
-    void skipVendorID(tinyxml2::XMLElement const* element);
-#endif
+    void registerDeleter(std::string const& name, std::pair<std::string, CommandData> const& commandData);
+    void unlinkCommandFromHandle(std::string const& name);
+    void writeArgumentPlainType(std::ostream & os, ParamData const& paramData) const;
+    void writeArguments(std::ostream & os, CommandData const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool firstCall, bool singular, size_t from, size_t to) const;
+    void writeArgumentVector(std::ostream & os, size_t paramIndex, ParamData const& paramData, size_t returnParamIndex, size_t templateParamIndex, bool twoStep, bool firstCall, bool singular) const;
+    void writeArgumentVulkanType(std::ostream & os, ParamData const& paramData) const;
+    void writeCommand(std::ostream &os, std::string const& indentation, std::string const& name, std::pair<std::string, CommandData> const& commandData, bool definition) const;
+    void writeEnum(std::ostream & os, std::pair<std::string,EnumData> const& enumData) const;
+    void writeFunction(std::ostream & os, std::string const& indentation, std::string const& name, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool definition, bool enhanced, bool singular, bool unique, bool isStructureChain, bool withAllocator) const;
+    void writeFunctionBodyEnhanced(std::ostream & os, std::string const& indentation, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool singular, bool unique, bool isStructureChain, bool withAllocator) const;
+    std::string writeFunctionBodyEnhancedLocalReturnVariable(std::ostream & os, std::string const& indentation, CommandData const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, std::string const& enhancedReturnType, bool singular, bool isStructureChain, bool withAllocator) const;
+    void writeFunctionBodyEnhancedLocalReturnVariableVectorSize(std::ostream & os, std::vector<ParamData> const& params, std::pair<size_t, size_t> const& vectorParamIndex, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool withAllocator) const;
+    void writeFunctionBodyEnhancedMultiVectorSizeCheck(std::ostream & os, std::string const& indentation, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices) const;
+    void writeFunctionBodyEnhancedReturnResultValue(std::ostream & os, std::string const& indentation, std::string const& returnName, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, bool twoStep, bool singular, bool unique) const;
+    void writeFunctionBodyEnhancedSingleStep(std::ostream & os, std::string const& indentation, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular) const;
+    void writeFunctionBodyEnhancedTwoStep(std::ostream & os, std::string const& indentation, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular, std::string const& returnName) const;
+    void writeFunctionBodyEnhancedVectorOfUniqueHandles(std::ostream & os, std::string const& indentation, std::string const& commandName, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool twoStep, bool singular, bool withAllocator) const;
+    void writeFunctionBodyStandard(std::ostream & os, std::string const& indentation, std::pair<std::string, CommandData> const& commandData) const;
+    std::string writeFunctionBodyStandardArgument(TypeData const& typeData, std::string const& name) const;
+    bool writeFunctionHeaderArgumentEnhanced(std::ostream & os, ParamData const& param, size_t paramIndex, std::map<size_t, size_t> const& vectorParamIndices, bool skip, bool argEncountered, bool isTemplateParam, bool isLastArgument, bool singular, bool withDefaults, bool withAllocator) const;
+    void writeFunctionHeaderArgumentEnhancedPointer(std::ostream & os, ParamData const& param, std::string const& strippedParameterName, bool withDefaults, bool withAllocator) const;
+    void writeFunctionHeaderArgumentEnhancedSimple(std::ostream & os, ParamData const& param, bool lastArgument, bool withDefaults, bool withAllocator) const;
+    void writeFunctionHeaderArgumentEnhancedVector(std::ostream & os, ParamData const& param, std::string const& strippedParameterName, bool hasSizeParam, bool isTemplateParam, bool singular, bool withDefaults, bool withAllocator) const;
+    void writeFunctionHeaderArguments(std::ostream & os, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool enhanced, bool singular, bool withDefaults, bool withAllocator) const;
+    void writeFunctionHeaderArgumentsEnhanced(std::ostream & os, std::pair<std::string, CommandData> const& commandData, size_t returnParamIndex, size_t templateParamIndex, std::map<size_t, size_t> const& vectorParamIndices, bool singular, bool withDefaults, bool withAllocator) const;
+    void writeFunctionHeaderArgumentsStandard(std::ostream & os, std::pair<std::string, CommandData> const& commandData, bool withDefaults) const;
+    bool writeFunctionHeaderArgumentStandard(std::ostream & os, ParamData const& param, bool argEncountered, bool isLastArgument, bool withDefaults) const;
+    void writeFunctionHeaderReturnType(std::ostream & os, CommandData const& commandData, size_t returnParamIndex, std::map<size_t, size_t> const& vectorParamIndices, std::string const& enhancedReturnType, bool enhanced, bool singular, bool unique, bool isStructureChain) const;
+    void writeFunctionHeaderTemplate(std::ostream & os, std::string const& indentation, size_t returnParamIndex, size_t templateParamIndex, std::string const& enhancedReturnType, bool enhanced, bool singular, bool unique, bool withDefault, bool isStructureChain) const;
+    void writeHandle(std::ostream & os, std::pair<std::string, HandleData> const& handle, std::set<std::string> & listedHandles) const;
+    void writeStruct(std::ostream & os, std::pair<std::string, StructureData> const& structure, std::set<std::string> & listedStructures) const;
+    void writeStructCompareOperators(std::ostream & os, std::pair<std::string, StructureData> const& structure) const;
+    void writeStructConstructor(std::ostream & os, std::pair<std::string, StructureData> const& structData) const;
+    std::string writeStructConstructorArgument(bool & listedArgument, std::string const& indentation, MemberData const& memberData) const;
+    void writeStructMembers(std::ostream & os, StructureData const& structData) const;
+    void writeStructSetter(std::ostream & os, std::string const& structureName, MemberData const& memberData) const;
+    void writeStructure(std::ostream & os, std::pair<std::string, StructureData> const& structure) const;
+    void writeUnion(std::ostream & os, std::pair<std::string, StructureData> const& structure) const;
+    void writeUniqueTypes(std::ostream &os, std::string const& parentType, std::set<std::string> const& childrenTypes) const;
 
   private:
-    std::map<std::string, BitmaskData>            m_bitmasks;
-    std::map<std::string, CommandData>            m_commands;
-    std::map<std::string, std::string>            m_constants;
-    std::set<std::string>                         m_defines;
-    std::map<std::string, DeleterData>            m_deleters;     // map from child types to corresponding deleter data
-    std::map<std::string, std::set<std::string>>  m_deleterTypes; // map from parent type to set of child types
-    std::list<DependencyData>                     m_dependencies;
-    std::map<std::string, EnumData>               m_enums;
-    std::set<std::string>                         m_extendedStructs; // structs which are referenced by the structextends tag
-    std::map<std::string, HandleData>             m_handles;
-    std::map<std::string, std::string>            m_nameMap;
-    std::map<std::string, std::string>            m_platforms;
-    std::map<std::string, ScalarData>             m_scalars;
-    std::map<std::string, StructData>             m_structs;
-    std::set<std::string>                         m_tags;
-    std::string                                   m_typesafeCheck;
-    std::string                                   m_version;
-    std::set<std::string>                         m_vkTypes;
-    std::string                                   m_vulkanLicenseHeader;
+    std::map<std::string, std::string>    m_baseTypes;
+    std::map<std::string, EnumData>       m_bitmaskBits;
+    std::map<std::string, BitmaskData>    m_bitmasks;
+    std::map<std::string, std::string>    m_commandToHandle;
+    std::map<std::string, EnumData>       m_enums;
+    std::set<std::string>                 m_extendedStructs; // structs which are referenced by the structextends tag
+    std::map<std::string, HandleData>     m_handles;
+    std::map<std::string, std::string>    m_platforms;
+    std::map<std::string, std::string>    m_structureAliases;
+    std::map<std::string, StructureData>  m_structures;
+    std::set<std::string>                 m_tags;
+    std::string                           m_typesafeCheck;
+    std::string                           m_version;
+    std::string                           m_vulkanLicenseHeader;
 #if !defined(NDEBUG)
-    std::map<std::string, ExtensionData>          m_extensions;
-    std::vector<VendorIDData>                     m_vendorIDs;
+    std::set<std::string>                 m_defines;        // just used for verfication in readExtensionType
 #endif
-};
\ No newline at end of file
+};
+
+const size_t INVALID_INDEX = (size_t)~0;
diff --git a/tests/DeviceFunctions/DeviceFunctions.cpp b/tests/DeviceFunctions/DeviceFunctions.cpp
index 46c9acf..df8f816 100644
--- a/tests/DeviceFunctions/DeviceFunctions.cpp
+++ b/tests/DeviceFunctions/DeviceFunctions.cpp
@@ -51,6 +51,8 @@ int main(int /*argc*/, char * /*argv[]*/)
     std::vector<vk::UniqueCommandBuffer>::allocator_type vectorAllocator;
     std::vector<vk::UniqueCommandBuffer> commandBuffers = device->allocateCommandBuffersUnique({}, vectorAllocator, vk::DispatchLoaderStatic());
 
+    commandBuffers[0]->begin(nullptr);
+
     std::vector<vk::UniqueHandle<vk::CommandBuffer, vk::DispatchLoaderDynamic>>::allocator_type dynamicVectorAllocator;
     std::vector<vk::UniqueHandle<vk::CommandBuffer, vk::DispatchLoaderDynamic>> dynamicCommandBuffers = device->allocateCommandBuffersUnique({}, dynamicVectorAllocator, vk::DispatchLoaderDynamic());
   }
diff --git a/tests/StructureChain/StructureChain.cpp b/tests/StructureChain/StructureChain.cpp
index ea87383..244169f 100644
--- a/tests/StructureChain/StructureChain.cpp
+++ b/tests/StructureChain/StructureChain.cpp
@@ -71,6 +71,10 @@ int main(int /*argc*/, char * /*argv[]*/)
     auto d = pd.getFeatures2<vk::PhysicalDeviceFeatures2, vk::PhysicalDeviceVariablePointerFeatures>(vk::DispatchLoaderStatic());
     vk::PhysicalDeviceFeatures2 & d0 = d.get<vk::PhysicalDeviceFeatures2>();
     vk::PhysicalDeviceVariablePointerFeatures & d1 = d.get<vk::PhysicalDeviceVariablePointerFeatures>();
+
+    using StructureChain = vk::StructureChain<vk::QueueFamilyProperties2, vk::QueueFamilyCheckpointPropertiesNV>;
+    using AllocatorType = std::vector<StructureChain>::allocator_type;
+    auto qfd = pd.getQueueFamilyProperties2<StructureChain, AllocatorType>(vk::DispatchLoaderStatic());
   }
   catch (vk::SystemError err)
   {
diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp
index 92b333f..a5ecb7c 100644
--- a/vulkan/vulkan.hpp
+++ b/vulkan/vulkan.hpp
@@ -45,15 +45,27 @@
 #include <tuple>
 #include <type_traits>
 #include <vulkan/vulkan.h>
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+
+#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
 # include <memory>
 # include <vector>
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif
+
 #if !defined(VULKAN_HPP_ASSERT)
 # include <cassert>
 # define VULKAN_HPP_ASSERT   assert
 #endif
 
+static_assert( VK_HEADER_VERSION ==  94 , "Wrong VK_HEADER_VERSION!" );
+
+// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
+// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
+#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
+#  define VULKAN_HPP_TYPESAFE_CONVERSION
+# endif
+#endif
+
 // <tuple> includes <sys/sysmacros.h> through some other header
 // this results in major(x) being resolved to gnu_dev_major(x)
 // which is an expression in a constructor initializer list.
@@ -66,20 +78,10 @@
 
 // Windows defines MemoryBarrier which is deprecated and collides
 // with the vk::MemoryBarrier struct.
-#ifdef MemoryBarrier
+#if defined(MemoryBarrier)
   #undef MemoryBarrier
 #endif
 
-static_assert( VK_HEADER_VERSION ==  94 , "Wrong VK_HEADER_VERSION!" );
-
-// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
-// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
-#  define VULKAN_HPP_TYPESAFE_CONVERSION
-# endif
-#endif
-
 #if !defined(VULKAN_HPP_HAS_UNRESTRICTED_UNIONS)
 # if defined(__clang__)
 #  if __has_feature(cxx_unrestricted_unions)
@@ -125,7 +127,6 @@ static_assert( VK_HEADER_VERSION ==  94 , "Wrong VK_HEADER_VERSION!" );
 # define VULKAN_HPP_CONSTEXPR constexpr
 #endif
 
-
 #if !defined(VULKAN_HPP_NAMESPACE)
 #define VULKAN_HPP_NAMESPACE vk
 #endif
@@ -136,6 +137,97 @@ static_assert( VK_HEADER_VERSION ==  94 , "Wrong VK_HEADER_VERSION!" );
 
 namespace VULKAN_HPP_NAMESPACE
 {
+#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+  template <typename T>
+  class ArrayProxy
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t)
+      : m_count(0)
+      , m_ptr(nullptr)
+    {}
+
+    ArrayProxy(T & ptr)
+      : m_count(1)
+      , m_ptr(&ptr)
+    {}
+
+    ArrayProxy(uint32_t count, T * ptr)
+      : m_count(count)
+      , m_ptr(ptr)
+    {}
+
+    template <size_t N>
+    ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data)
+      : m_count(N)
+      , m_ptr(data.data())
+    {}
+
+    template <size_t N>
+    ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data)
+      : m_count(N)
+      , m_ptr(data.data())
+    {}
+
+    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
+    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data)
+      : m_count(static_cast<uint32_t>(data.size()))
+      , m_ptr(data.data())
+    {}
+
+    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
+    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data)
+      : m_count(static_cast<uint32_t>(data.size()))
+      , m_ptr(data.data())
+    {}
+
+    ArrayProxy(std::initializer_list<T> const& data)
+      : m_count(static_cast<uint32_t>(data.end() - data.begin()))
+      , m_ptr(data.begin())
+    {}
+
+    const T * begin() const
+    {
+      return m_ptr;
+    }
+
+    const T * end() const
+    {
+      return m_ptr + m_count;
+    }
+
+    const T & front() const
+    {
+      VULKAN_HPP_ASSERT(m_count && m_ptr);
+      return *m_ptr;
+    }
+
+    const T & back() const
+    {
+      VULKAN_HPP_ASSERT(m_count && m_ptr);
+      return *(m_ptr + m_count - 1);
+    }
+
+    bool empty() const
+    {
+      return (m_count == 0);
+    }
+
+    uint32_t size() const
+    {
+      return m_count;
+    }
+
+    T * data() const
+    {
+      return m_ptr;
+    }
+
+  private:
+    uint32_t  m_count;
+    T *       m_ptr;
+  };
+#endif
 
   template <typename FlagBitsType> struct FlagTraits
   {
@@ -265,7 +357,6 @@ namespace VULKAN_HPP_NAMESPACE
     return flags ^ bit;
   }
 
-
   template <typename RefType>
   class Optional
   {
@@ -282,204 +373,6 @@ namespace VULKAN_HPP_NAMESPACE
     RefType *m_ptr;
   };
 
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T>
-  class ArrayProxy
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t)
-      : m_count(0)
-      , m_ptr(nullptr)
-    {}
-
-    ArrayProxy(T & ptr)
-      : m_count(1)
-      , m_ptr(&ptr)
-    {}
-
-    ArrayProxy(uint32_t count, T * ptr)
-      : m_count(count)
-      , m_ptr(ptr)
-    {}
-
-    template <size_t N>
-    ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data)
-      : m_count(N)
-      , m_ptr(data.data())
-    {}
-
-    template <size_t N>
-    ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data)
-      : m_count(N)
-      , m_ptr(data.data())
-    {}
-
-    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
-    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data)
-      : m_count(static_cast<uint32_t>(data.size()))
-      , m_ptr(data.data())
-    {}
-
-    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
-    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data)
-      : m_count(static_cast<uint32_t>(data.size()))
-      , m_ptr(data.data())
-    {}
-
-    ArrayProxy(std::initializer_list<T> const& data)
-      : m_count(static_cast<uint32_t>(data.end() - data.begin()))
-      , m_ptr(data.begin())
-    {}
-
-    const T * begin() const
-    {
-      return m_ptr;
-    }
-
-    const T * end() const
-    {
-      return m_ptr + m_count;
-    }
-
-    const T & front() const
-    {
-      VULKAN_HPP_ASSERT(m_count && m_ptr);
-      return *m_ptr;
-    }
-
-    const T & back() const
-    {
-      VULKAN_HPP_ASSERT(m_count && m_ptr);
-      return *(m_ptr + m_count - 1);
-    }
-
-    bool empty() const
-    {
-      return (m_count == 0);
-    }
-
-    uint32_t size() const
-    {
-      return m_count;
-    }
-
-    T * data() const
-    {
-      return m_ptr;
-    }
-
-  private:
-    uint32_t  m_count;
-    T *       m_ptr;
-  };
-#endif
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-
-  template <typename Type, typename Dispatch> class UniqueHandleTraits;
-
-  template <typename Type, typename Dispatch>
-  class UniqueHandle : public UniqueHandleTraits<Type,Dispatch>::deleter
-  {
-  private:
-    using Deleter = typename UniqueHandleTraits<Type,Dispatch>::deleter;
-  public:
-    explicit UniqueHandle( Type const& value = Type(), Deleter const& deleter = Deleter() )
-      : Deleter( deleter)
-      , m_value( value )
-    {}
-
-    UniqueHandle( UniqueHandle const& ) = delete;
-
-    UniqueHandle( UniqueHandle && other )
-      : Deleter( std::move( static_cast<Deleter&>( other ) ) )
-      , m_value( other.release() )
-    {}
-
-    ~UniqueHandle()
-    {
-      if ( m_value ) this->destroy( m_value );
-    }
-
-    UniqueHandle & operator=( UniqueHandle const& ) = delete;
-
-    UniqueHandle & operator=( UniqueHandle && other )
-    {
-      reset( other.release() );
-      *static_cast<Deleter*>(this) = std::move( static_cast<Deleter&>(other) );
-      return *this;
-    }
-
-    explicit operator bool() const
-    {
-      return m_value.operator bool();
-    }
-
-    Type const* operator->() const
-    {
-      return &m_value;
-    }
-
-    Type * operator->()
-    {
-      return &m_value;
-    }
-
-    Type const& operator*() const
-    {
-      return m_value;
-    }
-
-    Type & operator*()
-    {
-      return m_value;
-    }
-
-    const Type & get() const
-    {
-      return m_value;
-    }
-    
-    Type & get()
-    {
-      return m_value;
-    }
-
-    void reset( Type const& value = Type() )
-    {
-      if ( m_value != value )
-      {
-        if ( m_value ) this->destroy( m_value );
-        m_value = value;
-      }
-    }
-
-    Type release()
-    {
-      Type value = m_value;
-      m_value = nullptr;
-      return value;
-    }
-
-    void swap( UniqueHandle<Type,Dispatch> & rhs )
-    {
-      std::swap(m_value, rhs.m_value);
-      std::swap(static_cast<Deleter&>(*this), static_cast<Deleter&>(rhs));
-    }
-
-  private:
-    Type    m_value;
-  };
-
-  template <typename Type, typename Dispatch>
-  VULKAN_HPP_INLINE void swap( UniqueHandle<Type,Dispatch> & lhs, UniqueHandle<Type,Dispatch> & rhs )
-  {
-    lhs.swap( rhs );
-  }
-#endif
-
-
-
   template <typename X, typename Y> struct isStructureChainValid { enum { value = false }; };
 
   template <typename P, typename T>
@@ -598,1923 +491,1865 @@ namespace VULKAN_HPP_NAMESPACE
     }
   };
 
-  enum class Result
-  {
-    eSuccess = VK_SUCCESS,
-    eNotReady = VK_NOT_READY,
-    eTimeout = VK_TIMEOUT,
-    eEventSet = VK_EVENT_SET,
-    eEventReset = VK_EVENT_RESET,
-    eIncomplete = VK_INCOMPLETE,
-    eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY,
-    eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY,
-    eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED,
-    eErrorDeviceLost = VK_ERROR_DEVICE_LOST,
-    eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED,
-    eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT,
-    eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT,
-    eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT,
-    eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER,
-    eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS,
-    eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED,
-    eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL,
-    eErrorOutOfPoolMemory = VK_ERROR_OUT_OF_POOL_MEMORY,
-    eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY,
-    eErrorInvalidExternalHandle = VK_ERROR_INVALID_EXTERNAL_HANDLE,
-    eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
-    eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR,
-    eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR,
-    eSuboptimalKHR = VK_SUBOPTIMAL_KHR,
-    eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR,
-    eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR,
-    eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT,
-    eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV,
-    eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT,
-    eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT,
-    eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT
-  };
+#if !defined(VULKAN_HPP_NO_SMART_HANDLE)
+  template <typename Type, typename Dispatch> class UniqueHandleTraits;
 
-  VULKAN_HPP_INLINE std::string to_string(Result value)
-  {
-    switch (value)
-    {
-    case Result::eSuccess: return "Success";
-    case Result::eNotReady: return "NotReady";
-    case Result::eTimeout: return "Timeout";
-    case Result::eEventSet: return "EventSet";
-    case Result::eEventReset: return "EventReset";
-    case Result::eIncomplete: return "Incomplete";
-    case Result::eErrorOutOfHostMemory: return "ErrorOutOfHostMemory";
-    case Result::eErrorOutOfDeviceMemory: return "ErrorOutOfDeviceMemory";
-    case Result::eErrorInitializationFailed: return "ErrorInitializationFailed";
-    case Result::eErrorDeviceLost: return "ErrorDeviceLost";
-    case Result::eErrorMemoryMapFailed: return "ErrorMemoryMapFailed";
-    case Result::eErrorLayerNotPresent: return "ErrorLayerNotPresent";
-    case Result::eErrorExtensionNotPresent: return "ErrorExtensionNotPresent";
-    case Result::eErrorFeatureNotPresent: return "ErrorFeatureNotPresent";
-    case Result::eErrorIncompatibleDriver: return "ErrorIncompatibleDriver";
-    case Result::eErrorTooManyObjects: return "ErrorTooManyObjects";
-    case Result::eErrorFormatNotSupported: return "ErrorFormatNotSupported";
-    case Result::eErrorFragmentedPool: return "ErrorFragmentedPool";
-    case Result::eErrorOutOfPoolMemory: return "ErrorOutOfPoolMemory";
-    case Result::eErrorInvalidExternalHandle: return "ErrorInvalidExternalHandle";
-    case Result::eErrorSurfaceLostKHR: return "ErrorSurfaceLostKHR";
-    case Result::eErrorNativeWindowInUseKHR: return "ErrorNativeWindowInUseKHR";
-    case Result::eSuboptimalKHR: return "SuboptimalKHR";
-    case Result::eErrorOutOfDateKHR: return "ErrorOutOfDateKHR";
-    case Result::eErrorIncompatibleDisplayKHR: return "ErrorIncompatibleDisplayKHR";
-    case Result::eErrorValidationFailedEXT: return "ErrorValidationFailedEXT";
-    case Result::eErrorInvalidShaderNV: return "ErrorInvalidShaderNV";
-    case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT";
-    case Result::eErrorFragmentationEXT: return "ErrorFragmentationEXT";
-    case Result::eErrorNotPermittedEXT: return "ErrorNotPermittedEXT";
-    default: return "invalid";
-    }
-  }
-
-#ifndef VULKAN_HPP_NO_EXCEPTIONS
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# define noexcept _NOEXCEPT
-#endif
-
-  class ErrorCategoryImpl : public std::error_category
-  {
-    public:
-    virtual const char* name() const noexcept override { return VULKAN_HPP_NAMESPACE_STRING"::Result"; }
-    virtual std::string message(int ev) const override { return to_string(static_cast<Result>(ev)); }
-  };
-
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# undef noexcept
-#endif
-
-  VULKAN_HPP_INLINE const std::error_category& errorCategory()
-  {
-    static ErrorCategoryImpl instance;
-    return instance;
-  }
-
-  VULKAN_HPP_INLINE std::error_code make_error_code(Result e)
-  {
-    return std::error_code(static_cast<int>(e), errorCategory());
-  }
-
-  VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e)
-  {
-    return std::error_condition(static_cast<int>(e), errorCategory());
-  }
-
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# define noexcept _NOEXCEPT
-#endif
-
-  class Error
-  {
-    public:
-    virtual ~Error() = default;
-
-    virtual const char* what() const noexcept = 0;
-  };
-
-  class LogicError : public Error, public std::logic_error
-  {
-    public:
-    explicit LogicError( const std::string& what )
-      : Error(), std::logic_error(what) {}
-    explicit LogicError( char const * what )
-      : Error(), std::logic_error(what) {}
-    virtual ~LogicError() = default;
-
-    virtual const char* what() const noexcept { return std::logic_error::what(); }
-  };
-
-  class SystemError : public Error, public std::system_error
-  {
-    public:
-    SystemError( std::error_code ec )
-      : Error(), std::system_error(ec) {}
-    SystemError( std::error_code ec, std::string const& what )
-      : Error(), std::system_error(ec, what) {}
-    SystemError( std::error_code ec, char const * what )
-      : Error(), std::system_error(ec, what) {}
-    SystemError( int ev, std::error_category const& ecat )
-      : Error(), std::system_error(ev, ecat) {}
-    SystemError( int ev, std::error_category const& ecat, std::string const& what)
-      : Error(), std::system_error(ev, ecat, what) {}
-    SystemError( int ev, std::error_category const& ecat, char const * what)
-      : Error(), std::system_error(ev, ecat, what) {}
-    virtual ~SystemError() = default;
-
-    virtual const char* what() const noexcept { return std::system_error::what(); }
-  };
-
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# undef noexcept
-#endif
-
-  class OutOfHostMemoryError : public SystemError
+  template <typename Type, typename Dispatch>
+  class UniqueHandle : public UniqueHandleTraits<Type,Dispatch>::deleter
   {
+  private:
+    using Deleter = typename UniqueHandleTraits<Type,Dispatch>::deleter;
   public:
-    OutOfHostMemoryError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
-    OutOfHostMemoryError( char const * message )
-      : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
-  };
-  class OutOfDeviceMemoryError : public SystemError
-  {
-  public:
-    OutOfDeviceMemoryError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
-    OutOfDeviceMemoryError( char const * message )
-      : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
-  };
-  class InitializationFailedError : public SystemError
-  {
-  public:
-    InitializationFailedError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
-    InitializationFailedError( char const * message )
-      : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
-  };
-  class DeviceLostError : public SystemError
-  {
-  public:
-    DeviceLostError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
-    DeviceLostError( char const * message )
-      : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
-  };
-  class MemoryMapFailedError : public SystemError
-  {
-  public:
-    MemoryMapFailedError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
-    MemoryMapFailedError( char const * message )
-      : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
-  };
-  class LayerNotPresentError : public SystemError
-  {
-  public:
-    LayerNotPresentError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
-    LayerNotPresentError( char const * message )
-      : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
-  };
-  class ExtensionNotPresentError : public SystemError
-  {
-  public:
-    ExtensionNotPresentError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
-    ExtensionNotPresentError( char const * message )
-      : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
-  };
-  class FeatureNotPresentError : public SystemError
-  {
-  public:
-    FeatureNotPresentError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
-    FeatureNotPresentError( char const * message )
-      : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
-  };
-  class IncompatibleDriverError : public SystemError
-  {
-  public:
-    IncompatibleDriverError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
-    IncompatibleDriverError( char const * message )
-      : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
-  };
-  class TooManyObjectsError : public SystemError
-  {
-  public:
-    TooManyObjectsError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
-    TooManyObjectsError( char const * message )
-      : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
-  };
-  class FormatNotSupportedError : public SystemError
-  {
-  public:
-    FormatNotSupportedError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
-    FormatNotSupportedError( char const * message )
-      : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
-  };
-  class FragmentedPoolError : public SystemError
-  {
-  public:
-    FragmentedPoolError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
-    FragmentedPoolError( char const * message )
-      : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
-  };
-  class OutOfPoolMemoryError : public SystemError
-  {
-  public:
-    OutOfPoolMemoryError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
-    OutOfPoolMemoryError( char const * message )
-      : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
-  };
-  class InvalidExternalHandleError : public SystemError
-  {
-  public:
-    InvalidExternalHandleError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
-    InvalidExternalHandleError( char const * message )
-      : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
-  };
-  class SurfaceLostKHRError : public SystemError
-  {
-  public:
-    SurfaceLostKHRError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
-    SurfaceLostKHRError( char const * message )
-      : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
-  };
-  class NativeWindowInUseKHRError : public SystemError
-  {
-  public:
-    NativeWindowInUseKHRError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
-    NativeWindowInUseKHRError( char const * message )
-      : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
-  };
-  class OutOfDateKHRError : public SystemError
-  {
-  public:
-    OutOfDateKHRError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
-    OutOfDateKHRError( char const * message )
-      : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
-  };
-  class IncompatibleDisplayKHRError : public SystemError
-  {
-  public:
-    IncompatibleDisplayKHRError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
-    IncompatibleDisplayKHRError( char const * message )
-      : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
-  };
-  class ValidationFailedEXTError : public SystemError
-  {
-  public:
-    ValidationFailedEXTError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
-    ValidationFailedEXTError( char const * message )
-      : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
-  };
-  class InvalidShaderNVError : public SystemError
-  {
-  public:
-    InvalidShaderNVError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
-    InvalidShaderNVError( char const * message )
-      : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
-  };
-  class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError
-  {
-  public:
-    InvalidDrmFormatModifierPlaneLayoutEXTError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) {}
-    InvalidDrmFormatModifierPlaneLayoutEXTError( char const * message )
-      : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) {}
-  };
-  class FragmentationEXTError : public SystemError
-  {
-  public:
-    FragmentationEXTError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorFragmentationEXT ), message ) {}
-    FragmentationEXTError( char const * message )
-      : SystemError( make_error_code( Result::eErrorFragmentationEXT ), message ) {}
-  };
-  class NotPermittedEXTError : public SystemError
-  {
-  public:
-    NotPermittedEXTError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {}
-    NotPermittedEXTError( char const * message )
-      : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {}
-  };
-
-  VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
-  {
-    switch ( result )
-    {
-    case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError ( message );
-    case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError ( message );
-    case Result::eErrorInitializationFailed: throw InitializationFailedError ( message );
-    case Result::eErrorDeviceLost: throw DeviceLostError ( message );
-    case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError ( message );
-    case Result::eErrorLayerNotPresent: throw LayerNotPresentError ( message );
-    case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError ( message );
-    case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError ( message );
-    case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError ( message );
-    case Result::eErrorTooManyObjects: throw TooManyObjectsError ( message );
-    case Result::eErrorFormatNotSupported: throw FormatNotSupportedError ( message );
-    case Result::eErrorFragmentedPool: throw FragmentedPoolError ( message );
-    case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError ( message );
-    case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError ( message );
-    case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError ( message );
-    case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError ( message );
-    case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError ( message );
-    case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError ( message );
-    case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError ( message );
-    case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError ( message );
-    case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError ( message );
-    case Result::eErrorFragmentationEXT: throw FragmentationEXTError ( message );
-    case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError ( message );
-    default: throw SystemError( make_error_code( result ) );
-    }
-  }
-#endif
-} // namespace VULKAN_HPP_NAMESPACE
-
-namespace std
-{
-  template <>
-  struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
-  {};
-}
-
-namespace VULKAN_HPP_NAMESPACE
-{
-
-  template <typename T>
-  struct ResultValue
-  {
-    ResultValue( Result r, T & v )
-      : result( r )
-      , value( v )
+    explicit UniqueHandle( Type const& value = Type(), Deleter const& deleter = Deleter() )
+      : Deleter( deleter)
+      , m_value( value )
     {}
 
-    ResultValue( Result r, T && v )
-      : result( r )
-      , value( std::move( v ) )
+    UniqueHandle( UniqueHandle const& ) = delete;
+
+    UniqueHandle( UniqueHandle && other )
+      : Deleter( std::move( static_cast<Deleter&>( other ) ) )
+      , m_value( other.release() )
     {}
 
-    Result  result;
-    T       value;
+    ~UniqueHandle()
+    {
+      if ( m_value ) this->destroy( m_value );
+    }
 
-    operator std::tuple<Result&, T&>() { return std::tuple<Result&, T&>(result, value); }
+    UniqueHandle & operator=( UniqueHandle const& ) = delete;
+
+    UniqueHandle & operator=( UniqueHandle && other )
+    {
+      reset( other.release() );
+      *static_cast<Deleter*>(this) = std::move( static_cast<Deleter&>(other) );
+      return *this;
+    }
+
+    explicit operator bool() const
+    {
+      return m_value.operator bool();
+    }
+
+    Type const* operator->() const
+    {
+      return &m_value;
+    }
+
+    Type * operator->()
+    {
+      return &m_value;
+    }
+
+    Type const& operator*() const
+    {
+      return m_value;
+    }
+
+    Type & operator*()
+    {
+      return m_value;
+    }
+
+    const Type & get() const
+    {
+      return m_value;
+    }
+    
+    Type & get()
+    {
+      return m_value;
+    }
+
+    void reset( Type const& value = Type() )
+    {
+      if ( m_value != value )
+      {
+        if ( m_value ) this->destroy( m_value );
+        m_value = value;
+      }
+    }
+
+    Type release()
+    {
+      Type value = m_value;
+      m_value = nullptr;
+      return value;
+    }
+
+    void swap( UniqueHandle<Type,Dispatch> & rhs )
+    {
+      std::swap(m_value, rhs.m_value);
+      std::swap(static_cast<Deleter&>(*this), static_cast<Deleter&>(rhs));
+    }
+
+  private:
+    Type    m_value;
   };
 
-  template <typename T>
-  struct ResultValueType
+  template <typename Type, typename Dispatch>
+  VULKAN_HPP_INLINE void swap( UniqueHandle<Type,Dispatch> & lhs, UniqueHandle<Type,Dispatch> & rhs )
   {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    typedef ResultValue<T>  type;
-#else
-    typedef T               type;
+    lhs.swap( rhs );
+  }
 #endif
-  };
 
-  template <>
-  struct ResultValueType<void>
+  class DispatchLoaderStatic
   {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    typedef Result type;
-#else
-    typedef void   type;
-#endif
-  };
-
-  template <typename T>
-  VULKAN_HPP_INLINE void ignore(T const&) {}
-
-  VULKAN_HPP_INLINE ResultValueType<void>::type createResultValue( Result result, char const * message )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    ignore( message );
-    VULKAN_HPP_ASSERT( result == Result::eSuccess );
-    return result;
-#else
-    if ( result != Result::eSuccess )
+  public:
+    VkResult vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance ) const
     {
-      throwResultException( result, message );
+      return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance );
     }
-#endif
-  }
 
-  template <typename T>
-  VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValue( Result result, T & data, char const * message )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    ignore( message );
-    VULKAN_HPP_ASSERT( result == Result::eSuccess );
-    return ResultValue<T>( result, std::move( data ) );
-#else
-    if ( result != Result::eSuccess )
+    VkResult vkEnumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties ) const
     {
-      throwResultException( result, message );
+      return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties );
     }
-    return std::move( data );
-#endif
-  }
 
-  VULKAN_HPP_INLINE Result createResultValue( Result result, char const * message, std::initializer_list<Result> successCodes )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    ignore( message );
-    VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
-#else
-    if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+    VkResult vkEnumerateInstanceLayerProperties( uint32_t* pPropertyCount, VkLayerProperties* pProperties ) const
     {
-      throwResultException( result, message );
+      return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties );
     }
-#endif
-    return result;
-  }
 
-  template <typename T>
-  VULKAN_HPP_INLINE ResultValue<T> createResultValue( Result result, T & data, char const * message, std::initializer_list<Result> successCodes )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    ignore( message );
-    VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
-#else
-    if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+    VkResult vkEnumerateInstanceVersion( uint32_t* pApiVersion ) const
     {
-      throwResultException( result, message );
+      return ::vkEnumerateInstanceVersion( pApiVersion );
     }
-#endif
-    return ResultValue<T>( result, data );
-  }
 
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename T, typename D>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<T,D>>::type createResultValue( Result result, T & data, char const * message, typename UniqueHandleTraits<T,D>::deleter const& deleter )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    ignore( message );
-    VULKAN_HPP_ASSERT( result == Result::eSuccess );
-    return ResultValue<UniqueHandle<T,D>>( result, UniqueHandle<T,D>(std::move( data ), deleter) );
-#else
-    if ( result != Result::eSuccess )
+    VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo ) const
     {
-      throwResultException( result, message );
+      return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo );
+    }
+
+    void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin ) const
+    {
+      return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin );
+    }
+
+    void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo ) const
+    {
+      return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
+    }
+
+    void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const
+    {
+      return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags );
+    }
+
+    void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const
+    {
+      return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index );
+    }
+
+    void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents ) const
+    {
+      return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents );
+    }
+
+    void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo ) const
+    {
+      return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
+    }
+
+    void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets ) const
+    {
+      return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
+    }
+
+    void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets ) const
+    {
+      return ::vkCmdBindDescriptorSets( commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets );
+    }
+
+    void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const
+    {
+      return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType );
+    }
+
+    void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const
+    {
+      return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline );
+    }
+
+    void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const
+    {
+      return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout );
+    }
+
+    void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes ) const
+    {
+      return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes );
+    }
+
+    void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets ) const
+    {
+      return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets );
+    }
+
+    void vkCmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter ) const
+    {
+      return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
+    }
+
+    void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset ) const
+    {
+      return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset );
+    }
+
+    void vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects ) const
+    {
+      return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects );
+    }
+
+    void vkCmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges ) const
+    {
+      return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges );
+    }
+
+    void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges ) const
+    {
+      return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges );
+    }
+
+    void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode ) const
+    {
+      return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode );
+    }
+
+    void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions ) const
+    {
+      return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions );
+    }
+
+    void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions ) const
+    {
+      return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
+    }
+
+    void vkCmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions ) const
+    {
+      return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+    }
+
+    void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions ) const
+    {
+      return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
+    }
+
+    void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags ) const
+    {
+      return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags );
+    }
+
+    void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo ) const
+    {
+      return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo );
+    }
+
+    void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const
+    {
+      return ::vkCmdDebugMarkerEndEXT( commandBuffer );
+    }
+
+    void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo ) const
+    {
+      return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo );
+    }
+
+    void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
+    {
+      return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ );
+    }
+
+    void vkCmdDispatchBase( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
+    {
+      return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+    }
+
+    void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
+    {
+      return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+    }
+
+    void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const
+    {
+      return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset );
+    }
+
+    void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const
+    {
+      return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
+    }
+
+    void vkCmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const
+    {
+      return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
+    }
+
+    void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride );
+    }
+
+    void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride );
+    }
+
+    void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride ) const
+    {
+      return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride );
+    }
+
+    void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+    }
+
+    void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+    {
+      return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride );
+    }
+
+    void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const
+    {
+      return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask );
+    }
+
+    void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const
+    {
+      return ::vkCmdEndConditionalRenderingEXT( commandBuffer );
+    }
+
+    void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const
+    {
+      return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer );
+    }
+
+    void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const
+    {
+      return ::vkCmdEndQuery( commandBuffer, queryPool, query );
+    }
+
+    void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const
+    {
+      return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index );
+    }
+
+    void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const
+    {
+      return ::vkCmdEndRenderPass( commandBuffer );
+    }
+
+    void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo ) const
+    {
+      return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo );
+    }
+
+    void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets ) const
+    {
+      return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
+    }
+
+    void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers ) const
+    {
+      return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers );
+    }
+
+    void vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const
+    {
+      return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data );
+    }
+
+    void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo ) const
+    {
+      return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
+    }
+
+    void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const
+    {
+      return ::vkCmdNextSubpass( commandBuffer, contents );
+    }
+
+    void vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo ) const
+    {
+      return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
+    }
+
+    void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers ) const
+    {
+      return ::vkCmdPipelineBarrier( commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers );
+    }
+
+    void vkCmdProcessCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo ) const
+    {
+      return ::vkCmdProcessCommandsNVX( commandBuffer, pProcessCommandsInfo );
+    }
+
+    void vkCmdPushConstants( VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues ) const
+    {
+      return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues );
+    }
+
+    void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites ) const
+    {
+      return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites );
+    }
+
+    void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData ) const
+    {
+      return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData );
+    }
+
+    void vkCmdReserveSpaceForCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo ) const
+    {
+      return ::vkCmdReserveSpaceForCommandsNVX( commandBuffer, pReserveSpaceInfo );
+    }
+
+    void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const
+    {
+      return ::vkCmdResetEvent( commandBuffer, event, stageMask );
+    }
+
+    void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const
+    {
+      return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount );
+    }
+
+    void vkCmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions ) const
+    {
+      return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+    }
+
+    void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const
+    {
+      return ::vkCmdSetBlendConstants( commandBuffer, blendConstants );
+    }
+
+    void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void* pCheckpointMarker ) const
+    {
+      return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker );
+    }
+
+    void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders ) const
+    {
+      return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
+    }
+
+    void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const
+    {
+      return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
+    }
+
+    void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const
+    {
+      return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds );
+    }
+
+    void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const
+    {
+      return ::vkCmdSetDeviceMask( commandBuffer, deviceMask );
+    }
+
+    void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const
+    {
+      return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask );
+    }
+
+    void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles ) const
+    {
+      return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles );
+    }
+
+    void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const
+    {
+      return ::vkCmdSetEvent( commandBuffer, event, stageMask );
+    }
+
+    void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors ) const
+    {
+      return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors );
+    }
+
+    void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const
+    {
+      return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
+    }
+
+    void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo ) const
+    {
+      return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo );
+    }
+
+    void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors ) const
+    {
+      return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors );
+    }
+
+    void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const
+    {
+      return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask );
+    }
+
+    void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const
+    {
+      return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference );
+    }
+
+    void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const
+    {
+      return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask );
+    }
+
+    void vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports ) const
+    {
+      return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports );
+    }
+
+    void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes ) const
+    {
+      return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes );
+    }
+
+    void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings ) const
+    {
+      return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings );
+    }
+
+    void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth ) const
+    {
+      return ::vkCmdTraceRaysNV( commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth );
+    }
+
+    void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData ) const
+    {
+      return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData );
+    }
+
+    void vkCmdWaitEvents( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers ) const
+    {
+      return ::vkCmdWaitEvents( commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers );
+    }
+
+    void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery ) const
+    {
+      return ::vkCmdWriteAccelerationStructuresPropertiesNV( commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
+    }
+
+    void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const
+    {
+      return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker );
+    }
+
+    void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query ) const
+    {
+      return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query );
+    }
+
+    VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const
+    {
+      return ::vkEndCommandBuffer( commandBuffer );
+    }
+
+    VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const
+    {
+      return ::vkResetCommandBuffer( commandBuffer, flags );
+    }
+
+    VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex ) const
+    {
+      return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex );
+    }
+
+    VkResult vkAcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex ) const
+    {
+      return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex );
+    }
+
+    VkResult vkAllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers ) const
+    {
+      return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
+    }
+
+    VkResult vkAllocateDescriptorSets( VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets ) const
+    {
+      return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets );
+    }
+
+    VkResult vkAllocateMemory( VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory ) const
+    {
+      return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory );
+    }
+
+    VkResult vkBindAccelerationStructureMemoryNV( VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos ) const
+    {
+      return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const
+    {
+      return ::vkBindBufferMemory( device, buffer, memory, memoryOffset );
+    }
+
+    VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos ) const
+    {
+      return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos ) const
+    {
+      return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const
+    {
+      return ::vkBindImageMemory( device, image, memory, memoryOffset );
+    }
+
+    VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos ) const
+    {
+      return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos ) const
+    {
+      return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const
+    {
+      return ::vkCompileDeferredNV( device, pipeline, shader );
+    }
+
+    VkResult vkCreateAccelerationStructureNV( VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure ) const
+    {
+      return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure );
+    }
+
+    VkResult vkCreateBuffer( VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer ) const
+    {
+      return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer );
+    }
+
+    VkResult vkCreateBufferView( VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView ) const
+    {
+      return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView );
+    }
+
+    VkResult vkCreateCommandPool( VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool ) const
+    {
+      return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool );
+    }
+
+    VkResult vkCreateComputePipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const
+    {
+      return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+    }
+
+    VkResult vkCreateDescriptorPool( VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool ) const
+    {
+      return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool );
+    }
+
+    VkResult vkCreateDescriptorSetLayout( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout ) const
+    {
+      return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout );
+    }
+
+    VkResult vkCreateDescriptorUpdateTemplate( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate ) const
+    {
+      return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
+    }
+
+    VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate ) const
+    {
+      return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
+    }
+
+    VkResult vkCreateEvent( VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent ) const
+    {
+      return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent );
+    }
+
+    VkResult vkCreateFence( VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const
+    {
+      return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence );
+    }
+
+    VkResult vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer ) const
+    {
+      return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer );
+    }
+
+    VkResult vkCreateGraphicsPipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const
+    {
+      return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+    }
+
+    VkResult vkCreateImage( VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage ) const
+    {
+      return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage );
+    }
+
+    VkResult vkCreateImageView( VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView ) const
+    {
+      return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView );
+    }
+
+    VkResult vkCreateIndirectCommandsLayoutNVX( VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout ) const
+    {
+      return ::vkCreateIndirectCommandsLayoutNVX( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
+    }
+
+    VkResult vkCreateObjectTableNVX( VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable ) const
+    {
+      return ::vkCreateObjectTableNVX( device, pCreateInfo, pAllocator, pObjectTable );
+    }
+
+    VkResult vkCreatePipelineCache( VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache ) const
+    {
+      return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache );
+    }
+
+    VkResult vkCreatePipelineLayout( VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout ) const
+    {
+      return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout );
+    }
+
+    VkResult vkCreateQueryPool( VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool ) const
+    {
+      return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool );
+    }
+
+    VkResult vkCreateRayTracingPipelinesNV( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const
+    {
+      return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+    }
+
+    VkResult vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass ) const
+    {
+      return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass );
+    }
+
+    VkResult vkCreateRenderPass2KHR( VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass ) const
+    {
+      return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass );
+    }
+
+    VkResult vkCreateSampler( VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler ) const
+    {
+      return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler );
+    }
+
+    VkResult vkCreateSamplerYcbcrConversion( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion ) const
+    {
+      return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion );
+    }
+
+    VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion ) const
+    {
+      return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion );
+    }
+
+    VkResult vkCreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore ) const
+    {
+      return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore );
+    }
+
+    VkResult vkCreateShaderModule( VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule ) const
+    {
+      return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule );
+    }
+
+    VkResult vkCreateSharedSwapchainsKHR( VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains ) const
+    {
+      return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains );
+    }
+
+    VkResult vkCreateSwapchainKHR( VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain ) const
+    {
+      return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain );
+    }
+
+    VkResult vkCreateValidationCacheEXT( VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache ) const
+    {
+      return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache );
+    }
+
+    VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo ) const
+    {
+      return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo );
+    }
+
+    VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo ) const
+    {
+      return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo );
+    }
+
+    void vkDestroyAccelerationStructureNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator );
+    }
+
+    void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyBuffer( device, buffer, pAllocator );
+    }
+
+    void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyBufferView( device, bufferView, pAllocator );
+    }
+
+    void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyCommandPool( device, commandPool, pAllocator );
+    }
+
+    void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator );
+    }
+
+    void vkDestroyDescriptorSetLayout( VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator );
+    }
+
+    void vkDestroyDescriptorUpdateTemplate( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator );
+    }
+
+    void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator );
+    }
+
+    void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDevice( device, pAllocator );
+    }
+
+    void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyEvent( device, event, pAllocator );
+    }
+
+    void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyFence( device, fence, pAllocator );
+    }
+
+    void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyFramebuffer( device, framebuffer, pAllocator );
+    }
+
+    void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyImage( device, image, pAllocator );
+    }
+
+    void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyImageView( device, imageView, pAllocator );
+    }
+
+    void vkDestroyIndirectCommandsLayoutNVX( VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyIndirectCommandsLayoutNVX( device, indirectCommandsLayout, pAllocator );
+    }
+
+    void vkDestroyObjectTableNVX( VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyObjectTableNVX( device, objectTable, pAllocator );
+    }
+
+    void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyPipeline( device, pipeline, pAllocator );
+    }
+
+    void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator );
+    }
+
+    void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator );
+    }
+
+    void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyQueryPool( device, queryPool, pAllocator );
+    }
+
+    void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyRenderPass( device, renderPass, pAllocator );
+    }
+
+    void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroySampler( device, sampler, pAllocator );
+    }
+
+    void vkDestroySamplerYcbcrConversion( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator );
+    }
+
+    void vkDestroySamplerYcbcrConversionKHR( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator );
+    }
+
+    void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroySemaphore( device, semaphore, pAllocator );
+    }
+
+    void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyShaderModule( device, shaderModule, pAllocator );
+    }
+
+    void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroySwapchainKHR( device, swapchain, pAllocator );
+    }
+
+    void vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator );
+    }
+
+    VkResult vkDeviceWaitIdle( VkDevice device ) const
+    {
+      return ::vkDeviceWaitIdle( device );
+    }
+
+    VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo ) const
+    {
+      return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo );
+    }
+
+    VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges ) const
+    {
+      return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
+    }
+
+    void vkFreeCommandBuffers( VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers ) const
+    {
+      return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers );
+    }
+
+    VkResult vkFreeDescriptorSets( VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets ) const
+    {
+      return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets );
+    }
+
+    void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkFreeMemory( device, memory, pAllocator );
+    }
+
+    VkResult vkGetAccelerationStructureHandleNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData ) const
+    {
+      return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData );
+    }
+
+    void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements ) const
+    {
+      return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
     }
-    return UniqueHandle<T,D>(data, deleter);
-#endif
-  }
-#endif
 
-class DispatchLoaderStatic
-{
-public:
-  VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex  ) const
-  {
-    return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex);
-  }
-  VkResult vkAcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex  ) const
-  {
-    return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex);
-  }
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-  VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display  ) const
-  {
-    return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display);
-  }
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-  VkResult vkAllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers  ) const
-  {
-    return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers);
-  }
-  VkResult vkAllocateDescriptorSets( VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets  ) const
-  {
-    return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets);
-  }
-  VkResult vkAllocateMemory( VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory  ) const
-  {
-    return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory);
-  }
-  VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo  ) const
-  {
-    return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo);
-  }
-  VkResult vkBindAccelerationStructureMemoryNV( VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos  ) const
-  {
-    return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos);
-  }
-  VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset  ) const
-  {
-    return ::vkBindBufferMemory( device, buffer, memory, memoryOffset);
-  }
-  VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos  ) const
-  {
-    return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos);
-  }
-  VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos  ) const
-  {
-    return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos);
-  }
-  VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset  ) const
-  {
-    return ::vkBindImageMemory( device, image, memory, memoryOffset);
-  }
-  VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos  ) const
-  {
-    return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos);
-  }
-  VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos  ) const
-  {
-    return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos);
-  }
-  void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin  ) const
-  {
-    return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin);
-  }
-  void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo  ) const
-  {
-    return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo);
-  }
-  void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags  ) const
-  {
-    return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags);
-  }
-  void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index  ) const
-  {
-    return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index);
-  }
-  void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents  ) const
-  {
-    return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents);
-  }
-  void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo  ) const
-  {
-    return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
-  }
-  void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets  ) const
-  {
-    return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-  }
-  void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets  ) const
-  {
-    return ::vkCmdBindDescriptorSets( commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
-  }
-  void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType  ) const
-  {
-    return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType);
-  }
-  void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline  ) const
-  {
-    return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline);
-  }
-  void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout  ) const
-  {
-    return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout);
-  }
-  void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes  ) const
-  {
-    return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
-  }
-  void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets  ) const
-  {
-    return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
-  }
-  void vkCmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter  ) const
-  {
-    return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
-  }
-  void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset  ) const
-  {
-    return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
-  }
-  void vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects  ) const
-  {
-    return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
-  }
-  void vkCmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges  ) const
-  {
-    return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
-  }
-  void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges  ) const
-  {
-    return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
-  }
-  void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode  ) const
-  {
-    return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode);
-  }
-  void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions  ) const
-  {
-    return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
-  }
-  void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions  ) const
-  {
-    return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
-  }
-  void vkCmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions  ) const
-  {
-    return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-  }
-  void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions  ) const
-  {
-    return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
-  }
-  void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags  ) const
-  {
-    return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
-  }
-  void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo  ) const
-  {
-    return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo);
-  }
-  void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer  ) const
-  {
-    return ::vkCmdDebugMarkerEndEXT( commandBuffer);
-  }
-  void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo  ) const
-  {
-    return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo);
-  }
-  void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ  ) const
-  {
-    return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ);
-  }
-  void vkCmdDispatchBase( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ  ) const
-  {
-    return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-  }
-  void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ  ) const
-  {
-    return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-  }
-  void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset  ) const
-  {
-    return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset);
-  }
-  void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance  ) const
-  {
-    return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
-  }
-  void vkCmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance  ) const
-  {
-    return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
-  }
-  void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride);
-  }
-  void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-  }
-  void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-  }
-  void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride);
-  }
-  void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride  ) const
-  {
-    return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
-  }
-  void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-  }
-  void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-  }
-  void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-  }
-  void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride  ) const
-  {
-    return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride);
-  }
-  void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask  ) const
-  {
-    return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask);
-  }
-  void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer  ) const
-  {
-    return ::vkCmdEndConditionalRenderingEXT( commandBuffer);
-  }
-  void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer  ) const
-  {
-    return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer);
-  }
-  void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query  ) const
-  {
-    return ::vkCmdEndQuery( commandBuffer, queryPool, query);
-  }
-  void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index  ) const
-  {
-    return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index);
-  }
-  void vkCmdEndRenderPass( VkCommandBuffer commandBuffer  ) const
-  {
-    return ::vkCmdEndRenderPass( commandBuffer);
-  }
-  void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo  ) const
-  {
-    return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo);
-  }
-  void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets  ) const
-  {
-    return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-  }
-  void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers  ) const
-  {
-    return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers);
-  }
-  void vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data  ) const
-  {
-    return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data);
-  }
-  void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo  ) const
-  {
-    return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo);
-  }
-  void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents  ) const
-  {
-    return ::vkCmdNextSubpass( commandBuffer, contents);
-  }
-  void vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo  ) const
-  {
-    return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
-  }
-  void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers  ) const
-  {
-    return ::vkCmdPipelineBarrier( commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-  }
-  void vkCmdProcessCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo  ) const
-  {
-    return ::vkCmdProcessCommandsNVX( commandBuffer, pProcessCommandsInfo);
-  }
-  void vkCmdPushConstants( VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues  ) const
-  {
-    return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues);
-  }
-  void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites  ) const
-  {
-    return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
-  }
-  void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData  ) const
-  {
-    return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData);
-  }
-  void vkCmdReserveSpaceForCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo  ) const
-  {
-    return ::vkCmdReserveSpaceForCommandsNVX( commandBuffer, pReserveSpaceInfo);
-  }
-  void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask  ) const
-  {
-    return ::vkCmdResetEvent( commandBuffer, event, stageMask);
-  }
-  void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount  ) const
-  {
-    return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount);
-  }
-  void vkCmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions  ) const
-  {
-    return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-  }
-  void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4]  ) const
-  {
-    return ::vkCmdSetBlendConstants( commandBuffer, blendConstants);
-  }
-  void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void* pCheckpointMarker  ) const
-  {
-    return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker);
-  }
-  void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders  ) const
-  {
-    return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
-  }
-  void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor  ) const
-  {
-    return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
-  }
-  void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds  ) const
-  {
-    return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds);
-  }
-  void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask  ) const
-  {
-    return ::vkCmdSetDeviceMask( commandBuffer, deviceMask);
-  }
-  void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask  ) const
-  {
-    return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask);
-  }
-  void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles  ) const
-  {
-    return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
-  }
-  void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask  ) const
-  {
-    return ::vkCmdSetEvent( commandBuffer, event, stageMask);
-  }
-  void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors  ) const
-  {
-    return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
-  }
-  void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth  ) const
-  {
-    return ::vkCmdSetLineWidth( commandBuffer, lineWidth);
-  }
-  void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo  ) const
-  {
-    return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo);
-  }
-  void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors  ) const
-  {
-    return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors);
-  }
-  void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask  ) const
-  {
-    return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask);
-  }
-  void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference  ) const
-  {
-    return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference);
-  }
-  void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask  ) const
-  {
-    return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask);
-  }
-  void vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports  ) const
-  {
-    return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports);
-  }
-  void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes  ) const
-  {
-    return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
-  }
-  void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings  ) const
-  {
-    return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings);
-  }
-  void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth  ) const
-  {
-    return ::vkCmdTraceRaysNV( commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
-  }
-  void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData  ) const
-  {
-    return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData);
-  }
-  void vkCmdWaitEvents( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers  ) const
-  {
-    return ::vkCmdWaitEvents( commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-  }
-  void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery  ) const
-  {
-    return ::vkCmdWriteAccelerationStructuresPropertiesNV( commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
-  }
-  void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker  ) const
-  {
-    return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
-  }
-  void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query  ) const
-  {
-    return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query);
-  }
-  VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader  ) const
-  {
-    return ::vkCompileDeferredNV( device, pipeline, shader);
-  }
-  VkResult vkCreateAccelerationStructureNV( VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure  ) const
-  {
-    return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure);
-  }
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-  VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ) const
+    {
+      return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties );
+    }
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-  VkResult vkCreateBuffer( VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer  ) const
-  {
-    return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer);
-  }
-  VkResult vkCreateBufferView( VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView  ) const
-  {
-    return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView);
-  }
-  VkResult vkCreateCommandPool( VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool  ) const
-  {
-    return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool);
-  }
-  VkResult vkCreateComputePipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines  ) const
-  {
-    return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-  }
-  VkResult vkCreateDebugReportCallbackEXT( VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback  ) const
-  {
-    return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback);
-  }
-  VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger  ) const
-  {
-    return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger);
-  }
-  VkResult vkCreateDescriptorPool( VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool  ) const
-  {
-    return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool);
-  }
-  VkResult vkCreateDescriptorSetLayout( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout  ) const
-  {
-    return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout);
-  }
-  VkResult vkCreateDescriptorUpdateTemplate( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate  ) const
-  {
-    return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-  }
-  VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate  ) const
-  {
-    return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-  }
-  VkResult vkCreateDevice( VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice  ) const
-  {
-    return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice);
-  }
-  VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode  ) const
-  {
-    return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode);
-  }
-  VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
-  }
-  VkResult vkCreateEvent( VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent  ) const
-  {
-    return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent);
-  }
-  VkResult vkCreateFence( VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence  ) const
-  {
-    return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence);
-  }
-  VkResult vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer  ) const
-  {
-    return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer);
-  }
-  VkResult vkCreateGraphicsPipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines  ) const
-  {
-    return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-  }
+
+    void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements ) const
+    {
+      return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements );
+    }
+
+    void vkGetBufferMemoryRequirements2( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const
+    {
+      return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetBufferMemoryRequirements2KHR( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const
+    {
+      return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
+    }
+
+    VkResult vkGetCalibratedTimestampsEXT( VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation ) const
+    {
+      return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
+    }
+
+    void vkGetDescriptorSetLayoutSupport( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport ) const
+    {
+      return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport );
+    }
+
+    void vkGetDescriptorSetLayoutSupportKHR( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport ) const
+    {
+      return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport );
+    }
+
+    void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures ) const
+    {
+      return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
+    }
+
+    void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures ) const
+    {
+      return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
+    }
+
+    VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities ) const
+    {
+      return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities );
+    }
+
+    VkResult vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes ) const
+    {
+      return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes );
+    }
+
+    void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes ) const
+    {
+      return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes );
+    }
+
+    PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char* pName ) const
+    {
+      return ::vkGetDeviceProcAddr( device, pName );
+    }
+
+    void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue ) const
+    {
+      return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue );
+    }
+
+    void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue ) const
+    {
+      return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue );
+    }
+
+    VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const
+    {
+      return ::vkGetEventStatus( device, event );
+    }
+
+    VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd ) const
+    {
+      return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd );
+    }
+
+    VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const
+    {
+      return ::vkGetFenceStatus( device, fence );
+    }
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const
+    {
+      return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties ) const
+    {
+      return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties );
+    }
+
+    void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements ) const
+    {
+      return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements );
+    }
+
+    void vkGetImageMemoryRequirements2( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const
+    {
+      return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetImageMemoryRequirements2KHR( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const
+    {
+      return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
+    }
+
+    void vkGetImageSparseMemoryRequirements( VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements ) const
+    {
+      return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+    }
+
+    void vkGetImageSparseMemoryRequirements2( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements ) const
+    {
+      return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+    }
+
+    void vkGetImageSparseMemoryRequirements2KHR( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements ) const
+    {
+      return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+    }
+
+    void vkGetImageSubresourceLayout( VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout ) const
+    {
+      return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout );
+    }
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer ) const
+    {
+      return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer );
+    }
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+    VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd ) const
+    {
+      return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd );
+    }
+
+    VkResult vkGetMemoryFdPropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties ) const
+    {
+      return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties );
+    }
+
+    VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties ) const
+    {
+      return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties );
+    }
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const
+    {
+      return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkGetMemoryWin32HandleNV( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) const
+    {
+      return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) const
+    {
+      return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings ) const
+    {
+      return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings );
+    }
+
+    VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData ) const
+    {
+      return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
+    }
+
+    VkResult vkGetQueryPoolResults( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags ) const
+    {
+      return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
+    }
+
+    VkResult vkGetRayTracingShaderGroupHandlesNV( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData ) const
+    {
+      return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData );
+    }
+
+    VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties ) const
+    {
+      return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties );
+    }
+
+    void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity ) const
+    {
+      return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
+    }
+
+    VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const
+    {
+      return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
+    }
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const
+    {
+      return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult vkGetShaderInfoAMD( VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo ) const
+    {
+      return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo );
+    }
+
+    VkResult vkGetSwapchainCounterEXT( VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue ) const
+    {
+      return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue );
+    }
+
+    VkResult vkGetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages ) const
+    {
+      return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages );
+    }
+
+    VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const
+    {
+      return ::vkGetSwapchainStatusKHR( device, swapchain );
+    }
+
+    VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData ) const
+    {
+      return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
+    }
+
+    VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo ) const
+    {
+      return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
+    }
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo ) const
+    {
+      return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo ) const
+    {
+      return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo );
+    }
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo ) const
+    {
+      return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo );
+    }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges ) const
+    {
+      return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
+    }
+
+    VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData ) const
+    {
+      return ::vkMapMemory( device, memory, offset, size, flags, ppData );
+    }
+
+    VkResult vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches ) const
+    {
+      return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches );
+    }
+
+    VkResult vkMergeValidationCachesEXT( VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches ) const
+    {
+      return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches );
+    }
+
+    VkResult vkRegisterDeviceEventEXT( VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const
+    {
+      return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence );
+    }
+
+    VkResult vkRegisterDisplayEventEXT( VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const
+    {
+      return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence );
+    }
+
+    VkResult vkRegisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices ) const
+    {
+      return ::vkRegisterObjectsNVX( device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices );
+    }
+
+    VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const
+    {
+      return ::vkResetCommandPool( device, commandPool, flags );
+    }
+
+    VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const
+    {
+      return ::vkResetDescriptorPool( device, descriptorPool, flags );
+    }
+
+    VkResult vkResetEvent( VkDevice device, VkEvent event ) const
+    {
+      return ::vkResetEvent( device, event );
+    }
+
+    VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences ) const
+    {
+      return ::vkResetFences( device, fenceCount, pFences );
+    }
+
+    VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo ) const
+    {
+      return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo );
+    }
+
+    VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo ) const
+    {
+      return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo );
+    }
+
+    VkResult vkSetEvent( VkDevice device, VkEvent event ) const
+    {
+      return ::vkSetEvent( device, event );
+    }
+
+    void vkSetHdrMetadataEXT( VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata ) const
+    {
+      return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata );
+    }
+
+    void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const
+    {
+      return ::vkTrimCommandPool( device, commandPool, flags );
+    }
+
+    void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const
+    {
+      return ::vkTrimCommandPoolKHR( device, commandPool, flags );
+    }
+
+    void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const
+    {
+      return ::vkUnmapMemory( device, memory );
+    }
+
+    VkResult vkUnregisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices ) const
+    {
+      return ::vkUnregisterObjectsNVX( device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices );
+    }
+
+    void vkUpdateDescriptorSetWithTemplate( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData ) const
+    {
+      return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData );
+    }
+
+    void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData ) const
+    {
+      return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData );
+    }
+
+    void vkUpdateDescriptorSets( VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies ) const
+    {
+      return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies );
+    }
+
+    VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout ) const
+    {
+      return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
+    }
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+    VkResult vkCreateDebugReportCallbackEXT( VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback ) const
+    {
+      return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback );
+    }
+
+    VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger ) const
+    {
+      return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
+    }
+
+    VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
+
 #ifdef VK_USE_PLATFORM_IOS_MVK
-  VkResult vkCreateIOSSurfaceMVK( VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateIOSSurfaceMVK( VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_IOS_MVK*/
-  VkResult vkCreateImage( VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage  ) const
-  {
-    return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage);
-  }
+
 #ifdef VK_USE_PLATFORM_FUCHSIA
-  VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
-  VkResult vkCreateImageView( VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView  ) const
-  {
-    return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView);
-  }
-  VkResult vkCreateIndirectCommandsLayoutNVX( VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout  ) const
-  {
-    return ::vkCreateIndirectCommandsLayoutNVX( device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
-  }
-  VkResult vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance  ) const
-  {
-    return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance);
-  }
+
 #ifdef VK_USE_PLATFORM_MACOS_MVK
-  VkResult vkCreateMacOSSurfaceMVK( VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateMacOSSurfaceMVK( VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
-  VkResult vkCreateObjectTableNVX( VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable  ) const
-  {
-    return ::vkCreateObjectTableNVX( device, pCreateInfo, pAllocator, pObjectTable);
-  }
-  VkResult vkCreatePipelineCache( VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache  ) const
-  {
-    return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache);
-  }
-  VkResult vkCreatePipelineLayout( VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout  ) const
-  {
-    return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout);
-  }
-  VkResult vkCreateQueryPool( VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool  ) const
-  {
-    return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool);
-  }
-  VkResult vkCreateRayTracingPipelinesNV( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines  ) const
-  {
-    return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-  }
-  VkResult vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass  ) const
-  {
-    return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass);
-  }
-  VkResult vkCreateRenderPass2KHR( VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass  ) const
-  {
-    return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass);
-  }
-  VkResult vkCreateSampler( VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler  ) const
-  {
-    return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler);
-  }
-  VkResult vkCreateSamplerYcbcrConversion( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion  ) const
-  {
-    return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion);
-  }
-  VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion  ) const
-  {
-    return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion);
-  }
-  VkResult vkCreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore  ) const
-  {
-    return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore);
-  }
-  VkResult vkCreateShaderModule( VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule  ) const
-  {
-    return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule);
-  }
-  VkResult vkCreateSharedSwapchainsKHR( VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains  ) const
-  {
-    return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
-  }
-  VkResult vkCreateSwapchainKHR( VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain  ) const
-  {
-    return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain);
-  }
-  VkResult vkCreateValidationCacheEXT( VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache  ) const
-  {
-    return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache);
-  }
+
 #ifdef VK_USE_PLATFORM_VI_NN
-  VkResult vkCreateViSurfaceNN( VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateViSurfaceNN( VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_VI_NN*/
+
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  VkResult vkCreateWaylandSurfaceKHR( VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateWaylandSurfaceKHR( VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkCreateWin32SurfaceKHR( VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateWin32SurfaceKHR( VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
 #ifdef VK_USE_PLATFORM_XCB_KHR
-  VkResult vkCreateXcbSurfaceKHR( VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateXcbSurfaceKHR( VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_XCB_KHR*/
+
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-  VkResult vkCreateXlibSurfaceKHR( VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface  ) const
-  {
-    return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
-  }
+    VkResult vkCreateXlibSurfaceKHR( VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
+    {
+      return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
-  VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo  ) const
-  {
-    return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo);
-  }
-  VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo  ) const
-  {
-    return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo);
-  }
-  void vkDebugReportMessageEXT( VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage  ) const
-  {
-    return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
-  }
-  void vkDestroyAccelerationStructureNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator);
-  }
-  void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyBuffer( device, buffer, pAllocator);
-  }
-  void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyBufferView( device, bufferView, pAllocator);
-  }
-  void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyCommandPool( device, commandPool, pAllocator);
-  }
-  void vkDestroyDebugReportCallbackEXT( VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator);
-  }
-  void vkDestroyDebugUtilsMessengerEXT( VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator);
-  }
-  void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator);
-  }
-  void vkDestroyDescriptorSetLayout( VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator);
-  }
-  void vkDestroyDescriptorUpdateTemplate( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator);
-  }
-  void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator);
-  }
-  void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyDevice( device, pAllocator);
-  }
-  void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyEvent( device, event, pAllocator);
-  }
-  void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyFence( device, fence, pAllocator);
-  }
-  void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyFramebuffer( device, framebuffer, pAllocator);
-  }
-  void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyImage( device, image, pAllocator);
-  }
-  void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyImageView( device, imageView, pAllocator);
-  }
-  void vkDestroyIndirectCommandsLayoutNVX( VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyIndirectCommandsLayoutNVX( device, indirectCommandsLayout, pAllocator);
-  }
-  void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyInstance( instance, pAllocator);
-  }
-  void vkDestroyObjectTableNVX( VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyObjectTableNVX( device, objectTable, pAllocator);
-  }
-  void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyPipeline( device, pipeline, pAllocator);
-  }
-  void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator);
-  }
-  void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator);
-  }
-  void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyQueryPool( device, queryPool, pAllocator);
-  }
-  void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyRenderPass( device, renderPass, pAllocator);
-  }
-  void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroySampler( device, sampler, pAllocator);
-  }
-  void vkDestroySamplerYcbcrConversion( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator);
-  }
-  void vkDestroySamplerYcbcrConversionKHR( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator);
-  }
-  void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroySemaphore( device, semaphore, pAllocator);
-  }
-  void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyShaderModule( device, shaderModule, pAllocator);
-  }
-  void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroySurfaceKHR( instance, surface, pAllocator);
-  }
-  void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroySwapchainKHR( device, swapchain, pAllocator);
-  }
-  void vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator);
-  }
-  VkResult vkDeviceWaitIdle( VkDevice device  ) const
-  {
-    return ::vkDeviceWaitIdle( device);
-  }
-  VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo  ) const
-  {
-    return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo);
-  }
-  VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer  ) const
-  {
-    return ::vkEndCommandBuffer( commandBuffer);
-  }
-  VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties  ) const
-  {
-    return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties);
-  }
-  VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties  ) const
-  {
-    return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties);
-  }
-  VkResult vkEnumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties  ) const
-  {
-    return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties);
-  }
-  VkResult vkEnumerateInstanceLayerProperties( uint32_t* pPropertyCount, VkLayerProperties* pProperties  ) const
-  {
-    return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties);
-  }
-  VkResult vkEnumerateInstanceVersion( uint32_t* pApiVersion  ) const
-  {
-    return ::vkEnumerateInstanceVersion( pApiVersion);
-  }
-  VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties  ) const
-  {
-    return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-  }
-  VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties  ) const
-  {
-    return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-  }
-  VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices  ) const
-  {
-    return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices);
-  }
-  VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges  ) const
-  {
-    return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges);
-  }
-  void vkFreeCommandBuffers( VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers  ) const
-  {
-    return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers);
-  }
-  VkResult vkFreeDescriptorSets( VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets  ) const
-  {
-    return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets);
-  }
-  void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator  ) const
-  {
-    return ::vkFreeMemory( device, memory, pAllocator);
-  }
-  VkResult vkGetAccelerationStructureHandleNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData  ) const
-  {
-    return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData);
-  }
-  void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements  ) const
-  {
-    return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements);
-  }
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties  ) const
-  {
-    return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties);
-  }
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-  void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements  ) const
-  {
-    return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements);
-  }
-  void vkGetBufferMemoryRequirements2( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements  ) const
-  {
-    return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements);
-  }
-  void vkGetBufferMemoryRequirements2KHR( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements  ) const
-  {
-    return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements);
-  }
-  VkResult vkGetCalibratedTimestampsEXT( VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation  ) const
-  {
-    return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
-  }
-  void vkGetDescriptorSetLayoutSupport( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport  ) const
-  {
-    return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport);
-  }
-  void vkGetDescriptorSetLayoutSupportKHR( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport  ) const
-  {
-    return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport);
-  }
-  void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures  ) const
-  {
-    return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-  }
-  void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures  ) const
-  {
-    return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-  }
-  VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities  ) const
-  {
-    return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities);
-  }
-  VkResult vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes  ) const
-  {
-    return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes);
-  }
-  void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes  ) const
-  {
-    return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes);
-  }
-  PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char* pName  ) const
-  {
-    return ::vkGetDeviceProcAddr( device, pName);
-  }
-  void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue  ) const
-  {
-    return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue);
-  }
-  void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue  ) const
-  {
-    return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue);
-  }
-  VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties  ) const
-  {
-    return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties);
-  }
-  VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties  ) const
-  {
-    return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties);
-  }
-  VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities  ) const
-  {
-    return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities);
-  }
-  VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities  ) const
-  {
-    return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities);
-  }
-  VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays  ) const
-  {
-    return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays);
-  }
-  VkResult vkGetEventStatus( VkDevice device, VkEvent event  ) const
-  {
-    return ::vkGetEventStatus( device, event);
-  }
-  VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd  ) const
-  {
-    return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd);
-  }
-  VkResult vkGetFenceStatus( VkDevice device, VkFence fence  ) const
-  {
-    return ::vkGetFenceStatus( device, fence);
-  }
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle  ) const
-  {
-    return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  VkResult vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties  ) const
-  {
-    return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties);
-  }
-  void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements  ) const
-  {
-    return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements);
-  }
-  void vkGetImageMemoryRequirements2( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements  ) const
-  {
-    return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements);
-  }
-  void vkGetImageMemoryRequirements2KHR( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements  ) const
-  {
-    return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements);
-  }
-  void vkGetImageSparseMemoryRequirements( VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements  ) const
-  {
-    return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-  }
-  void vkGetImageSparseMemoryRequirements2( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements  ) const
-  {
-    return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-  }
-  void vkGetImageSparseMemoryRequirements2KHR( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements  ) const
-  {
-    return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-  }
-  void vkGetImageSubresourceLayout( VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout  ) const
-  {
-    return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout);
-  }
-  PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char* pName  ) const
-  {
-    return ::vkGetInstanceProcAddr( instance, pName);
-  }
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer  ) const
-  {
-    return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer);
-  }
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-  VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd  ) const
-  {
-    return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd);
-  }
-  VkResult vkGetMemoryFdPropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties  ) const
-  {
-    return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties);
-  }
-  VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties  ) const
-  {
-    return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties);
-  }
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle  ) const
-  {
-    return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkGetMemoryWin32HandleNV( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle  ) const
-  {
-    return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties  ) const
-  {
-    return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings  ) const
-  {
-    return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings);
-  }
-  VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains  ) const
-  {
-    return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains);
-  }
-  VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties);
-  }
-  VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties);
-  }
-  VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties);
-  }
-  VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties);
-  }
-  void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-  }
-  void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-  }
-  void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-  }
-  void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-  }
-  VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV( physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
-  }
-  void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-  }
-  void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-  }
-  void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures  ) const
-  {
-    return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures);
-  }
-  void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures  ) const
-  {
-    return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures);
-  }
-  void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures  ) const
-  {
-    return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures);
-  }
-  void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties);
-  }
-  void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties);
-  }
-  void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties);
-  }
-  void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits  ) const
-  {
-    return ::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( physicalDevice, pFeatures, pLimits);
-  }
-  VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
-  }
-  VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties);
-  }
-  VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties);
-  }
-  void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties);
-  }
-  void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties);
-  }
-  void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties);
-  }
-  void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties);
-  }
-  VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects  ) const
-  {
-    return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects);
-  }
-  void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties);
-  }
-  void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties);
-  }
-  void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties);
-  }
-  void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-  }
-  void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-  }
-  void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-  }
-  void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
-  }
-  void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-  }
-  void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties  ) const
-  {
-    return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-  }
-  VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities);
-  }
-  VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
-  }
-  VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities);
-  }
-  VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
-  }
-  VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
-  }
-  VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes);
-  }
-  VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported  ) const
-  {
-    return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported);
-  }
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display  ) const
-  {
-    return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display);
-  }
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex  ) const
-  {
-    return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id  ) const
-  {
-    return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id);
-  }
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID  ) const
-  {
-    return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID);
-  }
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-  VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData  ) const
-  {
-    return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData);
-  }
-  VkResult vkGetQueryPoolResults( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags  ) const
-  {
-    return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
-  }
-  void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData  ) const
-  {
-    return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData);
-  }
+
+    void vkDebugReportMessageEXT( VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage ) const
+    {
+      return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage );
+    }
+
+    void vkDestroyDebugReportCallbackEXT( VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator );
+    }
+
+    void vkDestroyDebugUtilsMessengerEXT( VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
+    }
+
+    void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroyInstance( instance, pAllocator );
+    }
+
+    void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator ) const
+    {
+      return ::vkDestroySurfaceKHR( instance, surface, pAllocator );
+    }
+
+    VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties ) const
+    {
+      return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
+    }
+
+    VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties ) const
+    {
+      return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
+    }
+
+    VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices ) const
+    {
+      return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices );
+    }
+
+    PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char* pName ) const
+    {
+      return ::vkGetInstanceProcAddr( instance, pName );
+    }
+
+    void vkSubmitDebugUtilsMessageEXT( VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData ) const
+    {
+      return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData );
+    }
+
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-  VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay  ) const
-  {
-    return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay);
-  }
+    VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display ) const
+    {
+      return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display );
+    }
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-  VkResult vkGetRayTracingShaderGroupHandlesNV( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData  ) const
-  {
-    return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData);
-  }
-  VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties  ) const
-  {
-    return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties);
-  }
-  void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity  ) const
-  {
-    return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity);
-  }
-  VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd  ) const
-  {
-    return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd);
-  }
+
+    VkResult vkCreateDevice( VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice ) const
+    {
+      return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice );
+    }
+
+    VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode ) const
+    {
+      return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode );
+    }
+
+    VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties ) const
+    {
+      return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties );
+    }
+
+    VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties ) const
+    {
+      return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties ) const
+    {
+      return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties ) const
+    {
+      return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities ) const
+    {
+      return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities );
+    }
+
+    VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities ) const
+    {
+      return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities );
+    }
+
+    VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays ) const
+    {
+      return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays );
+    }
+
+    VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains ) const
+    {
+      return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains );
+    }
+
+    VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV( physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
+    }
+
+    void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties ) const
+    {
+      return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
+    }
+
+    void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures ) const
+    {
+      return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures );
+    }
+
+    void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures ) const
+    {
+      return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures );
+    }
+
+    void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures ) const
+    {
+      return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures );
+    }
+
+    void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties );
+    }
+
+    void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties );
+    }
+
+    void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties );
+    }
+
+    void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits ) const
+    {
+      return ::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( physicalDevice, pFeatures, pLimits );
+    }
+
+    VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties ) const
+    {
+      return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties );
+    }
+
+    void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties ) const
+    {
+      return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties );
+    }
+
+    void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties ) const
+    {
+      return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties );
+    }
+
+    void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties ) const
+    {
+      return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties );
+    }
+
+    void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties ) const
+    {
+      return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties );
+    }
+
+    VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects ) const
+    {
+      return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects );
+    }
+
+    void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties );
+    }
+
+    void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties );
+    }
+
+    void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties );
+    }
+
+    void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties ) const
+    {
+      return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+    }
+
+    void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties ) const
+    {
+      return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+    }
+
+    void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties ) const
+    {
+      return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+    }
+
+    void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties );
+    }
+
+    void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
+    }
+
+    void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties ) const
+    {
+      return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities ) const
+    {
+      return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities ) const
+    {
+      return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities ) const
+    {
+      return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats ) const
+    {
+      return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats ) const
+    {
+      return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes ) const
+    {
+      return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes );
+    }
+
+    VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported ) const
+    {
+      return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported );
+    }
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display ) const
+    {
+      return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display );
+    }
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle  ) const
-  {
-    return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle);
-  }
+    VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const
+    {
+      return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex );
+    }
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  VkResult vkGetShaderInfoAMD( VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo  ) const
-  {
-    return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
-  }
-  VkResult vkGetSwapchainCounterEXT( VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue  ) const
-  {
-    return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue);
-  }
-  VkResult vkGetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages  ) const
-  {
-    return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages);
-  }
-  VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain  ) const
-  {
-    return ::vkGetSwapchainStatusKHR( device, swapchain);
-  }
-  VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData  ) const
-  {
-    return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData);
-  }
-  VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo  ) const
-  {
-    return ::vkImportFenceFdKHR( device, pImportFenceFdInfo);
-  }
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo  ) const
-  {
-    return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo  ) const
-  {
-    return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo);
-  }
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo  ) const
-  {
-    return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo);
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges  ) const
-  {
-    return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges);
-  }
-  VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData  ) const
-  {
-    return ::vkMapMemory( device, memory, offset, size, flags, ppData);
-  }
-  VkResult vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches  ) const
-  {
-    return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches);
-  }
-  VkResult vkMergeValidationCachesEXT( VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches  ) const
-  {
-    return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches);
-  }
-  void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo  ) const
-  {
-    return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo);
-  }
-  VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence  ) const
-  {
-    return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence);
-  }
-  void vkQueueEndDebugUtilsLabelEXT( VkQueue queue  ) const
-  {
-    return ::vkQueueEndDebugUtilsLabelEXT( queue);
-  }
-  void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo  ) const
-  {
-    return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo);
-  }
-  VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR* pPresentInfo  ) const
-  {
-    return ::vkQueuePresentKHR( queue, pPresentInfo);
-  }
-  VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence  ) const
-  {
-    return ::vkQueueSubmit( queue, submitCount, pSubmits, fence);
-  }
-  VkResult vkQueueWaitIdle( VkQueue queue  ) const
-  {
-    return ::vkQueueWaitIdle( queue);
-  }
-  VkResult vkRegisterDeviceEventEXT( VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence  ) const
-  {
-    return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence);
-  }
-  VkResult vkRegisterDisplayEventEXT( VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence  ) const
-  {
-    return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence);
-  }
-  VkResult vkRegisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices  ) const
-  {
-    return ::vkRegisterObjectsNVX( device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
-  }
-  VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display  ) const
-  {
-    return ::vkReleaseDisplayEXT( physicalDevice, display);
-  }
-  VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags  ) const
-  {
-    return ::vkResetCommandBuffer( commandBuffer, flags);
-  }
-  VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags  ) const
-  {
-    return ::vkResetCommandPool( device, commandPool, flags);
-  }
-  VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags  ) const
-  {
-    return ::vkResetDescriptorPool( device, descriptorPool, flags);
-  }
-  VkResult vkResetEvent( VkDevice device, VkEvent event  ) const
-  {
-    return ::vkResetEvent( device, event);
-  }
-  VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences  ) const
-  {
-    return ::vkResetFences( device, fenceCount, pFences);
-  }
-  VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo  ) const
-  {
-    return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo);
-  }
-  VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo  ) const
-  {
-    return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo);
-  }
-  VkResult vkSetEvent( VkDevice device, VkEvent event  ) const
-  {
-    return ::vkSetEvent( device, event);
-  }
-  void vkSetHdrMetadataEXT( VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata  ) const
-  {
-    return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata);
-  }
-  void vkSubmitDebugUtilsMessageEXT( VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData  ) const
-  {
-    return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData);
-  }
-  void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags  ) const
-  {
-    return ::vkTrimCommandPool( device, commandPool, flags);
-  }
-  void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags  ) const
-  {
-    return ::vkTrimCommandPoolKHR( device, commandPool, flags);
-  }
-  void vkUnmapMemory( VkDevice device, VkDeviceMemory memory  ) const
-  {
-    return ::vkUnmapMemory( device, memory);
-  }
-  VkResult vkUnregisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices  ) const
-  {
-    return ::vkUnregisterObjectsNVX( device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
-  }
-  void vkUpdateDescriptorSetWithTemplate( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData  ) const
-  {
-    return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData);
-  }
-  void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData  ) const
-  {
-    return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData);
-  }
-  void vkUpdateDescriptorSets( VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies  ) const
-  {
-    return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
-  }
-  VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout  ) const
-  {
-    return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout);
-  }
-};
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ) const
+    {
+      return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id );
+    }
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ) const
+    {
+      return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID );
+    }
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+    VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay ) const
+    {
+      return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay );
+    }
+#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+    VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const
+    {
+      return ::vkReleaseDisplayEXT( physicalDevice, display );
+    }
+
+    void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData ) const
+    {
+      return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData );
+    }
+
+    void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo ) const
+    {
+      return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo );
+    }
+
+    VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence ) const
+    {
+      return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence );
+    }
+
+    void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const
+    {
+      return ::vkQueueEndDebugUtilsLabelEXT( queue );
+    }
+
+    void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo ) const
+    {
+      return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo );
+    }
+
+    VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR* pPresentInfo ) const
+    {
+      return ::vkQueuePresentKHR( queue, pPresentInfo );
+    }
+
+    VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence ) const
+    {
+      return ::vkQueueSubmit( queue, submitCount, pSubmits, fence );
+    }
+
+    VkResult vkQueueWaitIdle( VkQueue queue ) const
+    {
+      return ::vkQueueWaitIdle( queue );
+    }
+  };
 
   struct AllocationCallbacks;
 
@@ -2621,5422 +2456,43 @@ public:
       Dispatch const* m_dispatch;
   };
 
+  using Bool32 = uint32_t;
+  using DeviceSize = uint64_t;
   using SampleMask = uint32_t;
 
-  using Bool32 = uint32_t;
-
-  using DeviceSize = uint64_t;
-
-  enum class FramebufferCreateFlagBits
-  {
-  };
-
-  using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits, VkFramebufferCreateFlags>;
-
-  enum class QueryPoolCreateFlagBits
-  {
-  };
-
-  using QueryPoolCreateFlags = Flags<QueryPoolCreateFlagBits, VkQueryPoolCreateFlags>;
-
-  enum class RenderPassCreateFlagBits
-  {
-  };
-
-  using RenderPassCreateFlags = Flags<RenderPassCreateFlagBits, VkRenderPassCreateFlags>;
-
-  enum class PipelineLayoutCreateFlagBits
-  {
-  };
-
-  using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits, VkPipelineLayoutCreateFlags>;
-
-  enum class PipelineCacheCreateFlagBits
-  {
-  };
-
-  using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits, VkPipelineCacheCreateFlags>;
-
-  enum class PipelineDepthStencilStateCreateFlagBits
-  {
-  };
-
-  using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits, VkPipelineDepthStencilStateCreateFlags>;
-
-  enum class PipelineDynamicStateCreateFlagBits
-  {
-  };
-
-  using PipelineDynamicStateCreateFlags = Flags<PipelineDynamicStateCreateFlagBits, VkPipelineDynamicStateCreateFlags>;
-
-  enum class PipelineColorBlendStateCreateFlagBits
-  {
-  };
-
-  using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits, VkPipelineColorBlendStateCreateFlags>;
-
-  enum class PipelineMultisampleStateCreateFlagBits
-  {
-  };
-
-  using PipelineMultisampleStateCreateFlags = Flags<PipelineMultisampleStateCreateFlagBits, VkPipelineMultisampleStateCreateFlags>;
-
-  enum class PipelineRasterizationStateCreateFlagBits
-  {
-  };
-
-  using PipelineRasterizationStateCreateFlags = Flags<PipelineRasterizationStateCreateFlagBits, VkPipelineRasterizationStateCreateFlags>;
-
-  enum class PipelineViewportStateCreateFlagBits
-  {
-  };
-
-  using PipelineViewportStateCreateFlags = Flags<PipelineViewportStateCreateFlagBits, VkPipelineViewportStateCreateFlags>;
-
-  enum class PipelineTessellationStateCreateFlagBits
-  {
-  };
-
-  using PipelineTessellationStateCreateFlags = Flags<PipelineTessellationStateCreateFlagBits, VkPipelineTessellationStateCreateFlags>;
-
-  enum class PipelineInputAssemblyStateCreateFlagBits
-  {
-  };
-
-  using PipelineInputAssemblyStateCreateFlags = Flags<PipelineInputAssemblyStateCreateFlagBits, VkPipelineInputAssemblyStateCreateFlags>;
-
-  enum class PipelineVertexInputStateCreateFlagBits
-  {
-  };
-
-  using PipelineVertexInputStateCreateFlags = Flags<PipelineVertexInputStateCreateFlagBits, VkPipelineVertexInputStateCreateFlags>;
-
-  enum class PipelineShaderStageCreateFlagBits
-  {
-  };
-
-  using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits, VkPipelineShaderStageCreateFlags>;
-
-  enum class BufferViewCreateFlagBits
-  {
-  };
-
-  using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits, VkBufferViewCreateFlags>;
-
-  enum class InstanceCreateFlagBits
-  {
-  };
-
-  using InstanceCreateFlags = Flags<InstanceCreateFlagBits, VkInstanceCreateFlags>;
-
-  enum class DeviceCreateFlagBits
-  {
-  };
-
-  using DeviceCreateFlags = Flags<DeviceCreateFlagBits, VkDeviceCreateFlags>;
-
-  enum class SemaphoreCreateFlagBits
-  {
-  };
-
-  using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits, VkSemaphoreCreateFlags>;
-
-  enum class ShaderModuleCreateFlagBits
-  {
-  };
-
-  using ShaderModuleCreateFlags = Flags<ShaderModuleCreateFlagBits, VkShaderModuleCreateFlags>;
-
-  enum class EventCreateFlagBits
-  {
-  };
-
-  using EventCreateFlags = Flags<EventCreateFlagBits, VkEventCreateFlags>;
-
-  enum class MemoryMapFlagBits
-  {
-  };
-
-  using MemoryMapFlags = Flags<MemoryMapFlagBits, VkMemoryMapFlags>;
-
-  enum class DescriptorPoolResetFlagBits
-  {
-  };
-
-  using DescriptorPoolResetFlags = Flags<DescriptorPoolResetFlagBits, VkDescriptorPoolResetFlags>;
-
-  enum class DescriptorUpdateTemplateCreateFlagBits
-  {
-  };
-
-  using DescriptorUpdateTemplateCreateFlags = Flags<DescriptorUpdateTemplateCreateFlagBits, VkDescriptorUpdateTemplateCreateFlags>;
-
-  using DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags;
-
-  enum class DisplayModeCreateFlagBitsKHR
-  {
-  };
-
-  using DisplayModeCreateFlagsKHR = Flags<DisplayModeCreateFlagBitsKHR, VkDisplayModeCreateFlagsKHR>;
-
-  enum class DisplaySurfaceCreateFlagBitsKHR
-  {
-  };
-
-  using DisplaySurfaceCreateFlagsKHR = Flags<DisplaySurfaceCreateFlagBitsKHR, VkDisplaySurfaceCreateFlagsKHR>;
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  enum class AndroidSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR, VkAndroidSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-  enum class ViSurfaceCreateFlagBitsNN
-  {
-  };
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-  using ViSurfaceCreateFlagsNN = Flags<ViSurfaceCreateFlagBitsNN, VkViSurfaceCreateFlagsNN>;
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  enum class WaylandSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  using WaylandSurfaceCreateFlagsKHR = Flags<WaylandSurfaceCreateFlagBitsKHR, VkWaylandSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  enum class Win32SurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  using Win32SurfaceCreateFlagsKHR = Flags<Win32SurfaceCreateFlagBitsKHR, VkWin32SurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  enum class XlibSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  using XlibSurfaceCreateFlagsKHR = Flags<XlibSurfaceCreateFlagBitsKHR, VkXlibSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  enum class XcbSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  using XcbSurfaceCreateFlagsKHR = Flags<XcbSurfaceCreateFlagBitsKHR, VkXcbSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-  enum class IOSSurfaceCreateFlagBitsMVK
-  {
-  };
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-  using IOSSurfaceCreateFlagsMVK = Flags<IOSSurfaceCreateFlagBitsMVK, VkIOSSurfaceCreateFlagsMVK>;
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-  enum class MacOSSurfaceCreateFlagBitsMVK
-  {
-  };
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-  using MacOSSurfaceCreateFlagsMVK = Flags<MacOSSurfaceCreateFlagBitsMVK, VkMacOSSurfaceCreateFlagsMVK>;
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_FUCHSIA
-  enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA
-  {
-  };
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#ifdef VK_USE_PLATFORM_FUCHSIA
-  using ImagePipeSurfaceCreateFlagsFUCHSIA = Flags<ImagePipeSurfaceCreateFlagBitsFUCHSIA, VkImagePipeSurfaceCreateFlagsFUCHSIA>;
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-  enum class CommandPoolTrimFlagBits
-  {
-  };
-
-  using CommandPoolTrimFlags = Flags<CommandPoolTrimFlagBits, VkCommandPoolTrimFlags>;
-
-  using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags;
-
-  enum class PipelineViewportSwizzleStateCreateFlagBitsNV
-  {
-  };
-
-  using PipelineViewportSwizzleStateCreateFlagsNV = Flags<PipelineViewportSwizzleStateCreateFlagBitsNV, VkPipelineViewportSwizzleStateCreateFlagsNV>;
-
-  enum class PipelineDiscardRectangleStateCreateFlagBitsEXT
-  {
-  };
-
-  using PipelineDiscardRectangleStateCreateFlagsEXT = Flags<PipelineDiscardRectangleStateCreateFlagBitsEXT, VkPipelineDiscardRectangleStateCreateFlagsEXT>;
-
-  enum class PipelineCoverageToColorStateCreateFlagBitsNV
-  {
-  };
-
-  using PipelineCoverageToColorStateCreateFlagsNV = Flags<PipelineCoverageToColorStateCreateFlagBitsNV, VkPipelineCoverageToColorStateCreateFlagsNV>;
-
-  enum class PipelineCoverageModulationStateCreateFlagBitsNV
-  {
-  };
-
-  using PipelineCoverageModulationStateCreateFlagsNV = Flags<PipelineCoverageModulationStateCreateFlagBitsNV, VkPipelineCoverageModulationStateCreateFlagsNV>;
-
-  enum class ValidationCacheCreateFlagBitsEXT
-  {
-  };
-
-  using ValidationCacheCreateFlagsEXT = Flags<ValidationCacheCreateFlagBitsEXT, VkValidationCacheCreateFlagsEXT>;
-
-  enum class DebugUtilsMessengerCreateFlagBitsEXT
-  {
-  };
-
-  using DebugUtilsMessengerCreateFlagsEXT = Flags<DebugUtilsMessengerCreateFlagBitsEXT, VkDebugUtilsMessengerCreateFlagsEXT>;
-
-  enum class DebugUtilsMessengerCallbackDataFlagBitsEXT
-  {
-  };
-
-  using DebugUtilsMessengerCallbackDataFlagsEXT = Flags<DebugUtilsMessengerCallbackDataFlagBitsEXT, VkDebugUtilsMessengerCallbackDataFlagsEXT>;
-
-  enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT
-  {
-  };
-
-  using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags<PipelineRasterizationConservativeStateCreateFlagBitsEXT, VkPipelineRasterizationConservativeStateCreateFlagsEXT>;
-
-  enum class PipelineRasterizationStateStreamCreateFlagBitsEXT
-  {
-  };
-
-  using PipelineRasterizationStateStreamCreateFlagsEXT = Flags<PipelineRasterizationStateStreamCreateFlagBitsEXT, VkPipelineRasterizationStateStreamCreateFlagsEXT>;
-
-  class DeviceMemory
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DeviceMemory()
-      : m_deviceMemory(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t )
-      : m_deviceMemory(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory )
-      : m_deviceMemory( deviceMemory )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DeviceMemory & operator=(VkDeviceMemory deviceMemory)
-    {
-      m_deviceMemory = deviceMemory;
-      return *this; 
-    }
-#endif
-
-    DeviceMemory & operator=( std::nullptr_t )
-    {
-      m_deviceMemory = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DeviceMemory const & rhs ) const
-    {
-      return m_deviceMemory == rhs.m_deviceMemory;
-    }
-
-    bool operator!=(DeviceMemory const & rhs ) const
-    {
-      return m_deviceMemory != rhs.m_deviceMemory;
-    }
-
-    bool operator<(DeviceMemory const & rhs ) const
-    {
-      return m_deviceMemory < rhs.m_deviceMemory;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const
-    {
-      return m_deviceMemory;
-    }
-
-    explicit operator bool() const
-    {
-      return m_deviceMemory != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_deviceMemory == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDeviceMemory m_deviceMemory;
-  };
-
-  static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" );
-
-  class CommandPool
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR CommandPool()
-      : m_commandPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t )
-      : m_commandPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool )
-      : m_commandPool( commandPool )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    CommandPool & operator=(VkCommandPool commandPool)
-    {
-      m_commandPool = commandPool;
-      return *this; 
-    }
-#endif
-
-    CommandPool & operator=( std::nullptr_t )
-    {
-      m_commandPool = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( CommandPool const & rhs ) const
-    {
-      return m_commandPool == rhs.m_commandPool;
-    }
-
-    bool operator!=(CommandPool const & rhs ) const
-    {
-      return m_commandPool != rhs.m_commandPool;
-    }
-
-    bool operator<(CommandPool const & rhs ) const
-    {
-      return m_commandPool < rhs.m_commandPool;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const
-    {
-      return m_commandPool;
-    }
-
-    explicit operator bool() const
-    {
-      return m_commandPool != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_commandPool == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkCommandPool m_commandPool;
-  };
-
-  static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" );
-
-  class Buffer
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Buffer()
-      : m_buffer(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t )
-      : m_buffer(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer )
-      : m_buffer( buffer )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Buffer & operator=(VkBuffer buffer)
-    {
-      m_buffer = buffer;
-      return *this; 
-    }
-#endif
-
-    Buffer & operator=( std::nullptr_t )
-    {
-      m_buffer = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Buffer const & rhs ) const
-    {
-      return m_buffer == rhs.m_buffer;
-    }
-
-    bool operator!=(Buffer const & rhs ) const
-    {
-      return m_buffer != rhs.m_buffer;
-    }
-
-    bool operator<(Buffer const & rhs ) const
-    {
-      return m_buffer < rhs.m_buffer;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const
-    {
-      return m_buffer;
-    }
-
-    explicit operator bool() const
-    {
-      return m_buffer != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_buffer == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkBuffer m_buffer;
-  };
-
-  static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" );
-
-  class BufferView
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR BufferView()
-      : m_bufferView(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t )
-      : m_bufferView(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView )
-      : m_bufferView( bufferView )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    BufferView & operator=(VkBufferView bufferView)
-    {
-      m_bufferView = bufferView;
-      return *this; 
-    }
-#endif
-
-    BufferView & operator=( std::nullptr_t )
-    {
-      m_bufferView = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( BufferView const & rhs ) const
-    {
-      return m_bufferView == rhs.m_bufferView;
-    }
-
-    bool operator!=(BufferView const & rhs ) const
-    {
-      return m_bufferView != rhs.m_bufferView;
-    }
-
-    bool operator<(BufferView const & rhs ) const
-    {
-      return m_bufferView < rhs.m_bufferView;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const
-    {
-      return m_bufferView;
-    }
-
-    explicit operator bool() const
-    {
-      return m_bufferView != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_bufferView == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkBufferView m_bufferView;
-  };
-
-  static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" );
-
-  class Image
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Image()
-      : m_image(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Image( std::nullptr_t )
-      : m_image(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image )
-      : m_image( image )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Image & operator=(VkImage image)
-    {
-      m_image = image;
-      return *this; 
-    }
-#endif
-
-    Image & operator=( std::nullptr_t )
-    {
-      m_image = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Image const & rhs ) const
-    {
-      return m_image == rhs.m_image;
-    }
-
-    bool operator!=(Image const & rhs ) const
-    {
-      return m_image != rhs.m_image;
-    }
-
-    bool operator<(Image const & rhs ) const
-    {
-      return m_image < rhs.m_image;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const
-    {
-      return m_image;
-    }
-
-    explicit operator bool() const
-    {
-      return m_image != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_image == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkImage m_image;
-  };
-
-  static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" );
-
-  class ImageView
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR ImageView()
-      : m_imageView(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t )
-      : m_imageView(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView )
-      : m_imageView( imageView )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    ImageView & operator=(VkImageView imageView)
-    {
-      m_imageView = imageView;
-      return *this; 
-    }
-#endif
-
-    ImageView & operator=( std::nullptr_t )
-    {
-      m_imageView = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( ImageView const & rhs ) const
-    {
-      return m_imageView == rhs.m_imageView;
-    }
-
-    bool operator!=(ImageView const & rhs ) const
-    {
-      return m_imageView != rhs.m_imageView;
-    }
-
-    bool operator<(ImageView const & rhs ) const
-    {
-      return m_imageView < rhs.m_imageView;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const
-    {
-      return m_imageView;
-    }
-
-    explicit operator bool() const
-    {
-      return m_imageView != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_imageView == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkImageView m_imageView;
-  };
-
-  static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" );
-
-  class ShaderModule
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR ShaderModule()
-      : m_shaderModule(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t )
-      : m_shaderModule(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule )
-      : m_shaderModule( shaderModule )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    ShaderModule & operator=(VkShaderModule shaderModule)
-    {
-      m_shaderModule = shaderModule;
-      return *this; 
-    }
-#endif
-
-    ShaderModule & operator=( std::nullptr_t )
-    {
-      m_shaderModule = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( ShaderModule const & rhs ) const
-    {
-      return m_shaderModule == rhs.m_shaderModule;
-    }
-
-    bool operator!=(ShaderModule const & rhs ) const
-    {
-      return m_shaderModule != rhs.m_shaderModule;
-    }
-
-    bool operator<(ShaderModule const & rhs ) const
-    {
-      return m_shaderModule < rhs.m_shaderModule;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const
-    {
-      return m_shaderModule;
-    }
-
-    explicit operator bool() const
-    {
-      return m_shaderModule != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_shaderModule == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkShaderModule m_shaderModule;
-  };
-
-  static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" );
-
-  class Pipeline
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Pipeline()
-      : m_pipeline(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t )
-      : m_pipeline(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline )
-      : m_pipeline( pipeline )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Pipeline & operator=(VkPipeline pipeline)
-    {
-      m_pipeline = pipeline;
-      return *this; 
-    }
-#endif
-
-    Pipeline & operator=( std::nullptr_t )
-    {
-      m_pipeline = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Pipeline const & rhs ) const
-    {
-      return m_pipeline == rhs.m_pipeline;
-    }
-
-    bool operator!=(Pipeline const & rhs ) const
-    {
-      return m_pipeline != rhs.m_pipeline;
-    }
-
-    bool operator<(Pipeline const & rhs ) const
-    {
-      return m_pipeline < rhs.m_pipeline;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const
-    {
-      return m_pipeline;
-    }
-
-    explicit operator bool() const
-    {
-      return m_pipeline != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_pipeline == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkPipeline m_pipeline;
-  };
-
-  static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" );
-
-  class PipelineLayout
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR PipelineLayout()
-      : m_pipelineLayout(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t )
-      : m_pipelineLayout(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout )
-      : m_pipelineLayout( pipelineLayout )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    PipelineLayout & operator=(VkPipelineLayout pipelineLayout)
-    {
-      m_pipelineLayout = pipelineLayout;
-      return *this; 
-    }
-#endif
-
-    PipelineLayout & operator=( std::nullptr_t )
-    {
-      m_pipelineLayout = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( PipelineLayout const & rhs ) const
-    {
-      return m_pipelineLayout == rhs.m_pipelineLayout;
-    }
-
-    bool operator!=(PipelineLayout const & rhs ) const
-    {
-      return m_pipelineLayout != rhs.m_pipelineLayout;
-    }
-
-    bool operator<(PipelineLayout const & rhs ) const
-    {
-      return m_pipelineLayout < rhs.m_pipelineLayout;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const
-    {
-      return m_pipelineLayout;
-    }
-
-    explicit operator bool() const
-    {
-      return m_pipelineLayout != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_pipelineLayout == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkPipelineLayout m_pipelineLayout;
-  };
-
-  static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" );
-
-  class Sampler
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Sampler()
-      : m_sampler(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t )
-      : m_sampler(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler )
-      : m_sampler( sampler )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Sampler & operator=(VkSampler sampler)
-    {
-      m_sampler = sampler;
-      return *this; 
-    }
-#endif
-
-    Sampler & operator=( std::nullptr_t )
-    {
-      m_sampler = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Sampler const & rhs ) const
-    {
-      return m_sampler == rhs.m_sampler;
-    }
-
-    bool operator!=(Sampler const & rhs ) const
-    {
-      return m_sampler != rhs.m_sampler;
-    }
-
-    bool operator<(Sampler const & rhs ) const
-    {
-      return m_sampler < rhs.m_sampler;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const
-    {
-      return m_sampler;
-    }
-
-    explicit operator bool() const
-    {
-      return m_sampler != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_sampler == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSampler m_sampler;
-  };
-
-  static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" );
-
-  class DescriptorSet
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DescriptorSet()
-      : m_descriptorSet(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t )
-      : m_descriptorSet(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet )
-      : m_descriptorSet( descriptorSet )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DescriptorSet & operator=(VkDescriptorSet descriptorSet)
-    {
-      m_descriptorSet = descriptorSet;
-      return *this; 
-    }
-#endif
-
-    DescriptorSet & operator=( std::nullptr_t )
-    {
-      m_descriptorSet = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DescriptorSet const & rhs ) const
-    {
-      return m_descriptorSet == rhs.m_descriptorSet;
-    }
-
-    bool operator!=(DescriptorSet const & rhs ) const
-    {
-      return m_descriptorSet != rhs.m_descriptorSet;
-    }
-
-    bool operator<(DescriptorSet const & rhs ) const
-    {
-      return m_descriptorSet < rhs.m_descriptorSet;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const
-    {
-      return m_descriptorSet;
-    }
-
-    explicit operator bool() const
-    {
-      return m_descriptorSet != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_descriptorSet == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDescriptorSet m_descriptorSet;
-  };
-
-  static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" );
-
-  class DescriptorSetLayout
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DescriptorSetLayout()
-      : m_descriptorSetLayout(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t )
-      : m_descriptorSetLayout(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout )
-      : m_descriptorSetLayout( descriptorSetLayout )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout)
-    {
-      m_descriptorSetLayout = descriptorSetLayout;
-      return *this; 
-    }
-#endif
-
-    DescriptorSetLayout & operator=( std::nullptr_t )
-    {
-      m_descriptorSetLayout = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DescriptorSetLayout const & rhs ) const
-    {
-      return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
-    }
-
-    bool operator!=(DescriptorSetLayout const & rhs ) const
-    {
-      return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
-    }
-
-    bool operator<(DescriptorSetLayout const & rhs ) const
-    {
-      return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const
-    {
-      return m_descriptorSetLayout;
-    }
-
-    explicit operator bool() const
-    {
-      return m_descriptorSetLayout != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_descriptorSetLayout == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDescriptorSetLayout m_descriptorSetLayout;
-  };
-
-  static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" );
-
-  class DescriptorPool
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DescriptorPool()
-      : m_descriptorPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t )
-      : m_descriptorPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool )
-      : m_descriptorPool( descriptorPool )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DescriptorPool & operator=(VkDescriptorPool descriptorPool)
-    {
-      m_descriptorPool = descriptorPool;
-      return *this; 
-    }
-#endif
-
-    DescriptorPool & operator=( std::nullptr_t )
-    {
-      m_descriptorPool = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DescriptorPool const & rhs ) const
-    {
-      return m_descriptorPool == rhs.m_descriptorPool;
-    }
-
-    bool operator!=(DescriptorPool const & rhs ) const
-    {
-      return m_descriptorPool != rhs.m_descriptorPool;
-    }
-
-    bool operator<(DescriptorPool const & rhs ) const
-    {
-      return m_descriptorPool < rhs.m_descriptorPool;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const
-    {
-      return m_descriptorPool;
-    }
-
-    explicit operator bool() const
-    {
-      return m_descriptorPool != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_descriptorPool == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDescriptorPool m_descriptorPool;
-  };
-
-  static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" );
-
-  class Fence
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Fence()
-      : m_fence(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t )
-      : m_fence(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence )
-      : m_fence( fence )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Fence & operator=(VkFence fence)
-    {
-      m_fence = fence;
-      return *this; 
-    }
-#endif
-
-    Fence & operator=( std::nullptr_t )
-    {
-      m_fence = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Fence const & rhs ) const
-    {
-      return m_fence == rhs.m_fence;
-    }
-
-    bool operator!=(Fence const & rhs ) const
-    {
-      return m_fence != rhs.m_fence;
-    }
-
-    bool operator<(Fence const & rhs ) const
-    {
-      return m_fence < rhs.m_fence;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const
-    {
-      return m_fence;
-    }
-
-    explicit operator bool() const
-    {
-      return m_fence != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_fence == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkFence m_fence;
-  };
-
-  static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" );
-
-  class Semaphore
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Semaphore()
-      : m_semaphore(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t )
-      : m_semaphore(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore )
-      : m_semaphore( semaphore )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Semaphore & operator=(VkSemaphore semaphore)
-    {
-      m_semaphore = semaphore;
-      return *this; 
-    }
-#endif
-
-    Semaphore & operator=( std::nullptr_t )
-    {
-      m_semaphore = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Semaphore const & rhs ) const
-    {
-      return m_semaphore == rhs.m_semaphore;
-    }
-
-    bool operator!=(Semaphore const & rhs ) const
-    {
-      return m_semaphore != rhs.m_semaphore;
-    }
-
-    bool operator<(Semaphore const & rhs ) const
-    {
-      return m_semaphore < rhs.m_semaphore;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const
-    {
-      return m_semaphore;
-    }
-
-    explicit operator bool() const
-    {
-      return m_semaphore != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_semaphore == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSemaphore m_semaphore;
-  };
-
-  static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" );
-
-  class Event
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Event()
-      : m_event(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Event( std::nullptr_t )
-      : m_event(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event )
-      : m_event( event )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Event & operator=(VkEvent event)
-    {
-      m_event = event;
-      return *this; 
-    }
-#endif
-
-    Event & operator=( std::nullptr_t )
-    {
-      m_event = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Event const & rhs ) const
-    {
-      return m_event == rhs.m_event;
-    }
-
-    bool operator!=(Event const & rhs ) const
-    {
-      return m_event != rhs.m_event;
-    }
-
-    bool operator<(Event const & rhs ) const
-    {
-      return m_event < rhs.m_event;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const
-    {
-      return m_event;
-    }
-
-    explicit operator bool() const
-    {
-      return m_event != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_event == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkEvent m_event;
-  };
-
-  static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" );
-
-  class QueryPool
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR QueryPool()
-      : m_queryPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t )
-      : m_queryPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool )
-      : m_queryPool( queryPool )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    QueryPool & operator=(VkQueryPool queryPool)
-    {
-      m_queryPool = queryPool;
-      return *this; 
-    }
-#endif
-
-    QueryPool & operator=( std::nullptr_t )
-    {
-      m_queryPool = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( QueryPool const & rhs ) const
-    {
-      return m_queryPool == rhs.m_queryPool;
-    }
-
-    bool operator!=(QueryPool const & rhs ) const
-    {
-      return m_queryPool != rhs.m_queryPool;
-    }
-
-    bool operator<(QueryPool const & rhs ) const
-    {
-      return m_queryPool < rhs.m_queryPool;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const
-    {
-      return m_queryPool;
-    }
-
-    explicit operator bool() const
-    {
-      return m_queryPool != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_queryPool == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkQueryPool m_queryPool;
-  };
-
-  static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" );
-
-  class Framebuffer
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Framebuffer()
-      : m_framebuffer(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t )
-      : m_framebuffer(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer )
-      : m_framebuffer( framebuffer )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Framebuffer & operator=(VkFramebuffer framebuffer)
-    {
-      m_framebuffer = framebuffer;
-      return *this; 
-    }
-#endif
-
-    Framebuffer & operator=( std::nullptr_t )
-    {
-      m_framebuffer = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Framebuffer const & rhs ) const
-    {
-      return m_framebuffer == rhs.m_framebuffer;
-    }
-
-    bool operator!=(Framebuffer const & rhs ) const
-    {
-      return m_framebuffer != rhs.m_framebuffer;
-    }
-
-    bool operator<(Framebuffer const & rhs ) const
-    {
-      return m_framebuffer < rhs.m_framebuffer;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const
-    {
-      return m_framebuffer;
-    }
-
-    explicit operator bool() const
-    {
-      return m_framebuffer != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_framebuffer == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkFramebuffer m_framebuffer;
-  };
-
-  static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" );
-
-  class RenderPass
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR RenderPass()
-      : m_renderPass(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t )
-      : m_renderPass(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass )
-      : m_renderPass( renderPass )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    RenderPass & operator=(VkRenderPass renderPass)
-    {
-      m_renderPass = renderPass;
-      return *this; 
-    }
-#endif
-
-    RenderPass & operator=( std::nullptr_t )
-    {
-      m_renderPass = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( RenderPass const & rhs ) const
-    {
-      return m_renderPass == rhs.m_renderPass;
-    }
-
-    bool operator!=(RenderPass const & rhs ) const
-    {
-      return m_renderPass != rhs.m_renderPass;
-    }
-
-    bool operator<(RenderPass const & rhs ) const
-    {
-      return m_renderPass < rhs.m_renderPass;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const
-    {
-      return m_renderPass;
-    }
-
-    explicit operator bool() const
-    {
-      return m_renderPass != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_renderPass == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkRenderPass m_renderPass;
-  };
-
-  static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" );
-
-  class PipelineCache
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR PipelineCache()
-      : m_pipelineCache(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t )
-      : m_pipelineCache(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache )
-      : m_pipelineCache( pipelineCache )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    PipelineCache & operator=(VkPipelineCache pipelineCache)
-    {
-      m_pipelineCache = pipelineCache;
-      return *this; 
-    }
-#endif
-
-    PipelineCache & operator=( std::nullptr_t )
-    {
-      m_pipelineCache = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( PipelineCache const & rhs ) const
-    {
-      return m_pipelineCache == rhs.m_pipelineCache;
-    }
-
-    bool operator!=(PipelineCache const & rhs ) const
-    {
-      return m_pipelineCache != rhs.m_pipelineCache;
-    }
-
-    bool operator<(PipelineCache const & rhs ) const
-    {
-      return m_pipelineCache < rhs.m_pipelineCache;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const
-    {
-      return m_pipelineCache;
-    }
-
-    explicit operator bool() const
-    {
-      return m_pipelineCache != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_pipelineCache == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkPipelineCache m_pipelineCache;
-  };
-
-  static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" );
-
-  class ObjectTableNVX
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR ObjectTableNVX()
-      : m_objectTableNVX(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR ObjectTableNVX( std::nullptr_t )
-      : m_objectTableNVX(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX( VkObjectTableNVX objectTableNVX )
-      : m_objectTableNVX( objectTableNVX )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    ObjectTableNVX & operator=(VkObjectTableNVX objectTableNVX)
-    {
-      m_objectTableNVX = objectTableNVX;
-      return *this; 
-    }
-#endif
-
-    ObjectTableNVX & operator=( std::nullptr_t )
-    {
-      m_objectTableNVX = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( ObjectTableNVX const & rhs ) const
-    {
-      return m_objectTableNVX == rhs.m_objectTableNVX;
-    }
-
-    bool operator!=(ObjectTableNVX const & rhs ) const
-    {
-      return m_objectTableNVX != rhs.m_objectTableNVX;
-    }
-
-    bool operator<(ObjectTableNVX const & rhs ) const
-    {
-      return m_objectTableNVX < rhs.m_objectTableNVX;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkObjectTableNVX() const
-    {
-      return m_objectTableNVX;
-    }
-
-    explicit operator bool() const
-    {
-      return m_objectTableNVX != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_objectTableNVX == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkObjectTableNVX m_objectTableNVX;
-  };
-
-  static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" );
-
-  class IndirectCommandsLayoutNVX
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX()
-      : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX( std::nullptr_t )
-      : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX( VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX )
-      : m_indirectCommandsLayoutNVX( indirectCommandsLayoutNVX )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    IndirectCommandsLayoutNVX & operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX)
-    {
-      m_indirectCommandsLayoutNVX = indirectCommandsLayoutNVX;
-      return *this; 
-    }
-#endif
-
-    IndirectCommandsLayoutNVX & operator=( std::nullptr_t )
-    {
-      m_indirectCommandsLayoutNVX = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( IndirectCommandsLayoutNVX const & rhs ) const
-    {
-      return m_indirectCommandsLayoutNVX == rhs.m_indirectCommandsLayoutNVX;
-    }
-
-    bool operator!=(IndirectCommandsLayoutNVX const & rhs ) const
-    {
-      return m_indirectCommandsLayoutNVX != rhs.m_indirectCommandsLayoutNVX;
-    }
-
-    bool operator<(IndirectCommandsLayoutNVX const & rhs ) const
-    {
-      return m_indirectCommandsLayoutNVX < rhs.m_indirectCommandsLayoutNVX;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNVX() const
-    {
-      return m_indirectCommandsLayoutNVX;
-    }
-
-    explicit operator bool() const
-    {
-      return m_indirectCommandsLayoutNVX != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_indirectCommandsLayoutNVX == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkIndirectCommandsLayoutNVX m_indirectCommandsLayoutNVX;
-  };
-
-  static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" );
-
-  class DescriptorUpdateTemplate
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate()
-      : m_descriptorUpdateTemplate(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t )
-      : m_descriptorUpdateTemplate(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate )
-      : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DescriptorUpdateTemplate & operator=(VkDescriptorUpdateTemplate descriptorUpdateTemplate)
-    {
-      m_descriptorUpdateTemplate = descriptorUpdateTemplate;
-      return *this; 
-    }
-#endif
-
-    DescriptorUpdateTemplate & operator=( std::nullptr_t )
-    {
-      m_descriptorUpdateTemplate = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DescriptorUpdateTemplate const & rhs ) const
-    {
-      return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
-    }
-
-    bool operator!=(DescriptorUpdateTemplate const & rhs ) const
-    {
-      return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
-    }
-
-    bool operator<(DescriptorUpdateTemplate const & rhs ) const
-    {
-      return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const
-    {
-      return m_descriptorUpdateTemplate;
-    }
-
-    explicit operator bool() const
-    {
-      return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDescriptorUpdateTemplate m_descriptorUpdateTemplate;
-  };
-
-  static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" );
-
-  using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
-
-  class SamplerYcbcrConversion
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion()
-      : m_samplerYcbcrConversion(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t )
-      : m_samplerYcbcrConversion(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion )
-      : m_samplerYcbcrConversion( samplerYcbcrConversion )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    SamplerYcbcrConversion & operator=(VkSamplerYcbcrConversion samplerYcbcrConversion)
-    {
-      m_samplerYcbcrConversion = samplerYcbcrConversion;
-      return *this; 
-    }
-#endif
-
-    SamplerYcbcrConversion & operator=( std::nullptr_t )
-    {
-      m_samplerYcbcrConversion = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( SamplerYcbcrConversion const & rhs ) const
-    {
-      return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
-    }
-
-    bool operator!=(SamplerYcbcrConversion const & rhs ) const
-    {
-      return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
-    }
-
-    bool operator<(SamplerYcbcrConversion const & rhs ) const
-    {
-      return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const
-    {
-      return m_samplerYcbcrConversion;
-    }
-
-    explicit operator bool() const
-    {
-      return m_samplerYcbcrConversion != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_samplerYcbcrConversion == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSamplerYcbcrConversion m_samplerYcbcrConversion;
-  };
-
-  static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" );
-
-  using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
-
-  class ValidationCacheEXT
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR ValidationCacheEXT()
-      : m_validationCacheEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t )
-      : m_validationCacheEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT )
-      : m_validationCacheEXT( validationCacheEXT )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    ValidationCacheEXT & operator=(VkValidationCacheEXT validationCacheEXT)
-    {
-      m_validationCacheEXT = validationCacheEXT;
-      return *this; 
-    }
-#endif
-
-    ValidationCacheEXT & operator=( std::nullptr_t )
-    {
-      m_validationCacheEXT = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( ValidationCacheEXT const & rhs ) const
-    {
-      return m_validationCacheEXT == rhs.m_validationCacheEXT;
-    }
-
-    bool operator!=(ValidationCacheEXT const & rhs ) const
-    {
-      return m_validationCacheEXT != rhs.m_validationCacheEXT;
-    }
-
-    bool operator<(ValidationCacheEXT const & rhs ) const
-    {
-      return m_validationCacheEXT < rhs.m_validationCacheEXT;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const
-    {
-      return m_validationCacheEXT;
-    }
-
-    explicit operator bool() const
-    {
-      return m_validationCacheEXT != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_validationCacheEXT == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkValidationCacheEXT m_validationCacheEXT;
-  };
-
-  static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" );
-
-  class AccelerationStructureNV
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR AccelerationStructureNV()
-      : m_accelerationStructureNV(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t )
-      : m_accelerationStructureNV(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV )
-      : m_accelerationStructureNV( accelerationStructureNV )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    AccelerationStructureNV & operator=(VkAccelerationStructureNV accelerationStructureNV)
-    {
-      m_accelerationStructureNV = accelerationStructureNV;
-      return *this; 
-    }
-#endif
-
-    AccelerationStructureNV & operator=( std::nullptr_t )
-    {
-      m_accelerationStructureNV = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( AccelerationStructureNV const & rhs ) const
-    {
-      return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
-    }
-
-    bool operator!=(AccelerationStructureNV const & rhs ) const
-    {
-      return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
-    }
-
-    bool operator<(AccelerationStructureNV const & rhs ) const
-    {
-      return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const
-    {
-      return m_accelerationStructureNV;
-    }
-
-    explicit operator bool() const
-    {
-      return m_accelerationStructureNV != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_accelerationStructureNV == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkAccelerationStructureNV m_accelerationStructureNV;
-  };
-
-  static_assert( sizeof( AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), "handle and wrapper have different size!" );
-
-  class DisplayKHR
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DisplayKHR()
-      : m_displayKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t )
-      : m_displayKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR )
-      : m_displayKHR( displayKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DisplayKHR & operator=(VkDisplayKHR displayKHR)
-    {
-      m_displayKHR = displayKHR;
-      return *this; 
-    }
-#endif
-
-    DisplayKHR & operator=( std::nullptr_t )
-    {
-      m_displayKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DisplayKHR const & rhs ) const
-    {
-      return m_displayKHR == rhs.m_displayKHR;
-    }
-
-    bool operator!=(DisplayKHR const & rhs ) const
-    {
-      return m_displayKHR != rhs.m_displayKHR;
-    }
-
-    bool operator<(DisplayKHR const & rhs ) const
-    {
-      return m_displayKHR < rhs.m_displayKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const
-    {
-      return m_displayKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_displayKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_displayKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDisplayKHR m_displayKHR;
-  };
-
-  static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" );
-
-  class DisplayModeKHR
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DisplayModeKHR()
-      : m_displayModeKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t )
-      : m_displayModeKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR )
-      : m_displayModeKHR( displayModeKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR)
-    {
-      m_displayModeKHR = displayModeKHR;
-      return *this; 
-    }
-#endif
-
-    DisplayModeKHR & operator=( std::nullptr_t )
-    {
-      m_displayModeKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DisplayModeKHR const & rhs ) const
-    {
-      return m_displayModeKHR == rhs.m_displayModeKHR;
-    }
-
-    bool operator!=(DisplayModeKHR const & rhs ) const
-    {
-      return m_displayModeKHR != rhs.m_displayModeKHR;
-    }
-
-    bool operator<(DisplayModeKHR const & rhs ) const
-    {
-      return m_displayModeKHR < rhs.m_displayModeKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const
-    {
-      return m_displayModeKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_displayModeKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_displayModeKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDisplayModeKHR m_displayModeKHR;
-  };
-
-  static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" );
-
-  class SurfaceKHR
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR SurfaceKHR()
-      : m_surfaceKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t )
-      : m_surfaceKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR )
-      : m_surfaceKHR( surfaceKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR)
-    {
-      m_surfaceKHR = surfaceKHR;
-      return *this; 
-    }
-#endif
-
-    SurfaceKHR & operator=( std::nullptr_t )
-    {
-      m_surfaceKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( SurfaceKHR const & rhs ) const
-    {
-      return m_surfaceKHR == rhs.m_surfaceKHR;
-    }
-
-    bool operator!=(SurfaceKHR const & rhs ) const
-    {
-      return m_surfaceKHR != rhs.m_surfaceKHR;
-    }
-
-    bool operator<(SurfaceKHR const & rhs ) const
-    {
-      return m_surfaceKHR < rhs.m_surfaceKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const
-    {
-      return m_surfaceKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_surfaceKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_surfaceKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSurfaceKHR m_surfaceKHR;
-  };
-
-  static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" );
-
-  class SwapchainKHR
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR SwapchainKHR()
-      : m_swapchainKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t )
-      : m_swapchainKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR )
-      : m_swapchainKHR( swapchainKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR)
-    {
-      m_swapchainKHR = swapchainKHR;
-      return *this; 
-    }
-#endif
-
-    SwapchainKHR & operator=( std::nullptr_t )
-    {
-      m_swapchainKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( SwapchainKHR const & rhs ) const
-    {
-      return m_swapchainKHR == rhs.m_swapchainKHR;
-    }
-
-    bool operator!=(SwapchainKHR const & rhs ) const
-    {
-      return m_swapchainKHR != rhs.m_swapchainKHR;
-    }
-
-    bool operator<(SwapchainKHR const & rhs ) const
-    {
-      return m_swapchainKHR < rhs.m_swapchainKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const
-    {
-      return m_swapchainKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_swapchainKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_swapchainKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSwapchainKHR m_swapchainKHR;
-  };
-
-  static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" );
-
-  class DebugReportCallbackEXT
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT()
-      : m_debugReportCallbackEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t )
-      : m_debugReportCallbackEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT )
-      : m_debugReportCallbackEXT( debugReportCallbackEXT )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT)
-    {
-      m_debugReportCallbackEXT = debugReportCallbackEXT;
-      return *this; 
-    }
-#endif
-
-    DebugReportCallbackEXT & operator=( std::nullptr_t )
-    {
-      m_debugReportCallbackEXT = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DebugReportCallbackEXT const & rhs ) const
-    {
-      return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
-    }
-
-    bool operator!=(DebugReportCallbackEXT const & rhs ) const
-    {
-      return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
-    }
-
-    bool operator<(DebugReportCallbackEXT const & rhs ) const
-    {
-      return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const
-    {
-      return m_debugReportCallbackEXT;
-    }
-
-    explicit operator bool() const
-    {
-      return m_debugReportCallbackEXT != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_debugReportCallbackEXT == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDebugReportCallbackEXT m_debugReportCallbackEXT;
-  };
-
-  static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" );
-
-  class DebugUtilsMessengerEXT
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT()
-      : m_debugUtilsMessengerEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t )
-      : m_debugUtilsMessengerEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT )
-      : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DebugUtilsMessengerEXT & operator=(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)
-    {
-      m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
-      return *this; 
-    }
-#endif
-
-    DebugUtilsMessengerEXT & operator=( std::nullptr_t )
-    {
-      m_debugUtilsMessengerEXT = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DebugUtilsMessengerEXT const & rhs ) const
-    {
-      return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
-    }
-
-    bool operator!=(DebugUtilsMessengerEXT const & rhs ) const
-    {
-      return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
-    }
-
-    bool operator<(DebugUtilsMessengerEXT const & rhs ) const
-    {
-      return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const
-    {
-      return m_debugUtilsMessengerEXT;
-    }
-
-    explicit operator bool() const
-    {
-      return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT;
-  };
-
-  static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" );
-
-  struct Offset2D
-  {
-    Offset2D( int32_t x_ = 0,
-              int32_t y_ = 0 )
-      : x( x_ )
-      , y( y_ )
-    {
-    }
-
-    Offset2D( VkOffset2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Offset2D ) );
-    }
-
-    Offset2D& operator=( VkOffset2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Offset2D ) );
-      return *this;
-    }
-    Offset2D& setX( int32_t x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    Offset2D& setY( int32_t y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    operator VkOffset2D const&() const
-    {
-      return *reinterpret_cast<const VkOffset2D*>(this);
-    }
-
-    operator VkOffset2D &()
-    {
-      return *reinterpret_cast<VkOffset2D*>(this);
-    }
-
-    bool operator==( Offset2D const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y );
-    }
-
-    bool operator!=( Offset2D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    int32_t x;
-    int32_t y;
-  };
-  static_assert( sizeof( Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" );
-
-  struct Offset3D
-  {
-    Offset3D( int32_t x_ = 0,
-              int32_t y_ = 0,
-              int32_t z_ = 0 )
-      : x( x_ )
-      , y( y_ )
-      , z( z_ )
-    {
-    }
-
-    explicit Offset3D( Offset2D const& offset2D,
-                       int32_t z_ = 0 )
-      : x( offset2D.x )
-      , y( offset2D.y )
-      , z( z_ )
-    {}
-
-    Offset3D( VkOffset3D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Offset3D ) );
-    }
-
-    Offset3D& operator=( VkOffset3D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Offset3D ) );
-      return *this;
-    }
-    Offset3D& setX( int32_t x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    Offset3D& setY( int32_t y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    Offset3D& setZ( int32_t z_ )
-    {
-      z = z_;
-      return *this;
-    }
-
-    operator VkOffset3D const&() const
-    {
-      return *reinterpret_cast<const VkOffset3D*>(this);
-    }
-
-    operator VkOffset3D &()
-    {
-      return *reinterpret_cast<VkOffset3D*>(this);
-    }
-
-    bool operator==( Offset3D const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y )
-          && ( z == rhs.z );
-    }
-
-    bool operator!=( Offset3D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    int32_t x;
-    int32_t y;
-    int32_t z;
-  };
-  static_assert( sizeof( Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" );
-
-  struct Extent2D
-  {
-    Extent2D( uint32_t width_ = 0,
-              uint32_t height_ = 0 )
-      : width( width_ )
-      , height( height_ )
-    {
-    }
-
-    Extent2D( VkExtent2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Extent2D ) );
-    }
-
-    Extent2D& operator=( VkExtent2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Extent2D ) );
-      return *this;
-    }
-    Extent2D& setWidth( uint32_t width_ )
-    {
-      width = width_;
-      return *this;
-    }
-
-    Extent2D& setHeight( uint32_t height_ )
-    {
-      height = height_;
-      return *this;
-    }
-
-    operator VkExtent2D const&() const
-    {
-      return *reinterpret_cast<const VkExtent2D*>(this);
-    }
-
-    operator VkExtent2D &()
-    {
-      return *reinterpret_cast<VkExtent2D*>(this);
-    }
-
-    bool operator==( Extent2D const& rhs ) const
-    {
-      return ( width == rhs.width )
-          && ( height == rhs.height );
-    }
-
-    bool operator!=( Extent2D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t width;
-    uint32_t height;
-  };
-  static_assert( sizeof( Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" );
-
-  struct Extent3D
-  {
-    Extent3D( uint32_t width_ = 0,
-              uint32_t height_ = 0,
-              uint32_t depth_ = 0 )
-      : width( width_ )
-      , height( height_ )
-      , depth( depth_ )
-    {
-    }
-
-    explicit Extent3D( Extent2D const& extent2D,
-                       uint32_t depth_ = 0 )
-      : width( extent2D.width )
-      , height( extent2D.height )
-      , depth( depth_ )
-    {}
-
-    Extent3D( VkExtent3D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Extent3D ) );
-    }
-
-    Extent3D& operator=( VkExtent3D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Extent3D ) );
-      return *this;
-    }
-    Extent3D& setWidth( uint32_t width_ )
-    {
-      width = width_;
-      return *this;
-    }
-
-    Extent3D& setHeight( uint32_t height_ )
-    {
-      height = height_;
-      return *this;
-    }
-
-    Extent3D& setDepth( uint32_t depth_ )
-    {
-      depth = depth_;
-      return *this;
-    }
-
-    operator VkExtent3D const&() const
-    {
-      return *reinterpret_cast<const VkExtent3D*>(this);
-    }
-
-    operator VkExtent3D &()
-    {
-      return *reinterpret_cast<VkExtent3D*>(this);
-    }
-
-    bool operator==( Extent3D const& rhs ) const
-    {
-      return ( width == rhs.width )
-          && ( height == rhs.height )
-          && ( depth == rhs.depth );
-    }
-
-    bool operator!=( Extent3D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t width;
-    uint32_t height;
-    uint32_t depth;
-  };
-  static_assert( sizeof( Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" );
-
-  struct Viewport
-  {
-    Viewport( float x_ = 0,
-              float y_ = 0,
-              float width_ = 0,
-              float height_ = 0,
-              float minDepth_ = 0,
-              float maxDepth_ = 0 )
-      : x( x_ )
-      , y( y_ )
-      , width( width_ )
-      , height( height_ )
-      , minDepth( minDepth_ )
-      , maxDepth( maxDepth_ )
-    {
-    }
-
-    Viewport( VkViewport const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Viewport ) );
-    }
-
-    Viewport& operator=( VkViewport const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Viewport ) );
-      return *this;
-    }
-    Viewport& setX( float x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    Viewport& setY( float y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    Viewport& setWidth( float width_ )
-    {
-      width = width_;
-      return *this;
-    }
-
-    Viewport& setHeight( float height_ )
-    {
-      height = height_;
-      return *this;
-    }
-
-    Viewport& setMinDepth( float minDepth_ )
-    {
-      minDepth = minDepth_;
-      return *this;
-    }
-
-    Viewport& setMaxDepth( float maxDepth_ )
-    {
-      maxDepth = maxDepth_;
-      return *this;
-    }
-
-    operator VkViewport const&() const
-    {
-      return *reinterpret_cast<const VkViewport*>(this);
-    }
-
-    operator VkViewport &()
-    {
-      return *reinterpret_cast<VkViewport*>(this);
-    }
-
-    bool operator==( Viewport const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y )
-          && ( width == rhs.width )
-          && ( height == rhs.height )
-          && ( minDepth == rhs.minDepth )
-          && ( maxDepth == rhs.maxDepth );
-    }
-
-    bool operator!=( Viewport const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float x;
-    float y;
-    float width;
-    float height;
-    float minDepth;
-    float maxDepth;
-  };
-  static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" );
-
-  struct Rect2D
-  {
-    Rect2D( Offset2D offset_ = Offset2D(),
-            Extent2D extent_ = Extent2D() )
-      : offset( offset_ )
-      , extent( extent_ )
-    {
-    }
-
-    Rect2D( VkRect2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Rect2D ) );
-    }
-
-    Rect2D& operator=( VkRect2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Rect2D ) );
-      return *this;
-    }
-    Rect2D& setOffset( Offset2D offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    Rect2D& setExtent( Extent2D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    operator VkRect2D const&() const
-    {
-      return *reinterpret_cast<const VkRect2D*>(this);
-    }
-
-    operator VkRect2D &()
-    {
-      return *reinterpret_cast<VkRect2D*>(this);
-    }
-
-    bool operator==( Rect2D const& rhs ) const
-    {
-      return ( offset == rhs.offset )
-          && ( extent == rhs.extent );
-    }
-
-    bool operator!=( Rect2D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Offset2D offset;
-    Extent2D extent;
-  };
-  static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" );
-
-  struct ClearRect
-  {
-    ClearRect( Rect2D rect_ = Rect2D(),
-               uint32_t baseArrayLayer_ = 0,
-               uint32_t layerCount_ = 0 )
-      : rect( rect_ )
-      , baseArrayLayer( baseArrayLayer_ )
-      , layerCount( layerCount_ )
-    {
-    }
-
-    ClearRect( VkClearRect const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearRect ) );
-    }
-
-    ClearRect& operator=( VkClearRect const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearRect ) );
-      return *this;
-    }
-    ClearRect& setRect( Rect2D rect_ )
-    {
-      rect = rect_;
-      return *this;
-    }
-
-    ClearRect& setBaseArrayLayer( uint32_t baseArrayLayer_ )
-    {
-      baseArrayLayer = baseArrayLayer_;
-      return *this;
-    }
-
-    ClearRect& setLayerCount( uint32_t layerCount_ )
-    {
-      layerCount = layerCount_;
-      return *this;
-    }
-
-    operator VkClearRect const&() const
-    {
-      return *reinterpret_cast<const VkClearRect*>(this);
-    }
-
-    operator VkClearRect &()
-    {
-      return *reinterpret_cast<VkClearRect*>(this);
-    }
-
-    bool operator==( ClearRect const& rhs ) const
-    {
-      return ( rect == rhs.rect )
-          && ( baseArrayLayer == rhs.baseArrayLayer )
-          && ( layerCount == rhs.layerCount );
-    }
-
-    bool operator!=( ClearRect const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Rect2D rect;
-    uint32_t baseArrayLayer;
-    uint32_t layerCount;
-  };
-  static_assert( sizeof( ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" );
-
-  struct ExtensionProperties
-  {
-    operator VkExtensionProperties const&() const
-    {
-      return *reinterpret_cast<const VkExtensionProperties*>(this);
-    }
-
-    operator VkExtensionProperties &()
-    {
-      return *reinterpret_cast<VkExtensionProperties*>(this);
-    }
-
-    bool operator==( ExtensionProperties const& rhs ) const
-    {
-      return ( memcmp( extensionName, rhs.extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
-          && ( specVersion == rhs.specVersion );
-    }
-
-    bool operator!=( ExtensionProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
-    uint32_t specVersion;
-  };
-  static_assert( sizeof( ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" );
-
-  struct LayerProperties
-  {
-    operator VkLayerProperties const&() const
-    {
-      return *reinterpret_cast<const VkLayerProperties*>(this);
-    }
-
-    operator VkLayerProperties &()
-    {
-      return *reinterpret_cast<VkLayerProperties*>(this);
-    }
-
-    bool operator==( LayerProperties const& rhs ) const
-    {
-      return ( memcmp( layerName, rhs.layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
-          && ( specVersion == rhs.specVersion )
-          && ( implementationVersion == rhs.implementationVersion )
-          && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 );
-    }
-
-    bool operator!=( LayerProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    char layerName[VK_MAX_EXTENSION_NAME_SIZE];
-    uint32_t specVersion;
-    uint32_t implementationVersion;
-    char description[VK_MAX_DESCRIPTION_SIZE];
-  };
-  static_assert( sizeof( LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" );
-
-  struct AllocationCallbacks
-  {
-    AllocationCallbacks( void* pUserData_ = nullptr,
-                         PFN_vkAllocationFunction pfnAllocation_ = nullptr,
-                         PFN_vkReallocationFunction pfnReallocation_ = nullptr,
-                         PFN_vkFreeFunction pfnFree_ = nullptr,
-                         PFN_vkInternalAllocationNotification pfnInternalAllocation_ = nullptr,
-                         PFN_vkInternalFreeNotification pfnInternalFree_ = nullptr )
-      : pUserData( pUserData_ )
-      , pfnAllocation( pfnAllocation_ )
-      , pfnReallocation( pfnReallocation_ )
-      , pfnFree( pfnFree_ )
-      , pfnInternalAllocation( pfnInternalAllocation_ )
-      , pfnInternalFree( pfnInternalFree_ )
-    {
-    }
-
-    AllocationCallbacks( VkAllocationCallbacks const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
-    }
-
-    AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
-      return *this;
-    }
-    AllocationCallbacks& setPUserData( void* pUserData_ )
-    {
-      pUserData = pUserData_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ )
-    {
-      pfnAllocation = pfnAllocation_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ )
-    {
-      pfnReallocation = pfnReallocation_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnFree( PFN_vkFreeFunction pfnFree_ )
-    {
-      pfnFree = pfnFree_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ )
-    {
-      pfnInternalAllocation = pfnInternalAllocation_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ )
-    {
-      pfnInternalFree = pfnInternalFree_;
-      return *this;
-    }
-
-    operator VkAllocationCallbacks const&() const
-    {
-      return *reinterpret_cast<const VkAllocationCallbacks*>(this);
-    }
-
-    operator VkAllocationCallbacks &()
-    {
-      return *reinterpret_cast<VkAllocationCallbacks*>(this);
-    }
-
-    bool operator==( AllocationCallbacks const& rhs ) const
-    {
-      return ( pUserData == rhs.pUserData )
-          && ( pfnAllocation == rhs.pfnAllocation )
-          && ( pfnReallocation == rhs.pfnReallocation )
-          && ( pfnFree == rhs.pfnFree )
-          && ( pfnInternalAllocation == rhs.pfnInternalAllocation )
-          && ( pfnInternalFree == rhs.pfnInternalFree );
-    }
-
-    bool operator!=( AllocationCallbacks const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    void* pUserData;
-    PFN_vkAllocationFunction pfnAllocation;
-    PFN_vkReallocationFunction pfnReallocation;
-    PFN_vkFreeFunction pfnFree;
-    PFN_vkInternalAllocationNotification pfnInternalAllocation;
-    PFN_vkInternalFreeNotification pfnInternalFree;
-  };
-  static_assert( sizeof( AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" );
-
-  struct MemoryRequirements
-  {
-    operator VkMemoryRequirements const&() const
-    {
-      return *reinterpret_cast<const VkMemoryRequirements*>(this);
-    }
-
-    operator VkMemoryRequirements &()
-    {
-      return *reinterpret_cast<VkMemoryRequirements*>(this);
-    }
-
-    bool operator==( MemoryRequirements const& rhs ) const
-    {
-      return ( size == rhs.size )
-          && ( alignment == rhs.alignment )
-          && ( memoryTypeBits == rhs.memoryTypeBits );
-    }
-
-    bool operator!=( MemoryRequirements const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize size;
-    DeviceSize alignment;
-    uint32_t memoryTypeBits;
-  };
-  static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" );
-
-  struct DescriptorBufferInfo
-  {
-    DescriptorBufferInfo( Buffer buffer_ = Buffer(),
-                          DeviceSize offset_ = 0,
-                          DeviceSize range_ = 0 )
-      : buffer( buffer_ )
-      , offset( offset_ )
-      , range( range_ )
-    {
-    }
-
-    DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
-    }
-
-    DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
-      return *this;
-    }
-    DescriptorBufferInfo& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    DescriptorBufferInfo& setOffset( DeviceSize offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    DescriptorBufferInfo& setRange( DeviceSize range_ )
-    {
-      range = range_;
-      return *this;
-    }
-
-    operator VkDescriptorBufferInfo const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorBufferInfo*>(this);
-    }
-
-    operator VkDescriptorBufferInfo &()
-    {
-      return *reinterpret_cast<VkDescriptorBufferInfo*>(this);
-    }
-
-    bool operator==( DescriptorBufferInfo const& rhs ) const
-    {
-      return ( buffer == rhs.buffer )
-          && ( offset == rhs.offset )
-          && ( range == rhs.range );
-    }
-
-    bool operator!=( DescriptorBufferInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Buffer buffer;
-    DeviceSize offset;
-    DeviceSize range;
-  };
-  static_assert( sizeof( DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" );
-
-  struct SubresourceLayout
-  {
-    operator VkSubresourceLayout const&() const
-    {
-      return *reinterpret_cast<const VkSubresourceLayout*>(this);
-    }
-
-    operator VkSubresourceLayout &()
-    {
-      return *reinterpret_cast<VkSubresourceLayout*>(this);
-    }
-
-    bool operator==( SubresourceLayout const& rhs ) const
-    {
-      return ( offset == rhs.offset )
-          && ( size == rhs.size )
-          && ( rowPitch == rhs.rowPitch )
-          && ( arrayPitch == rhs.arrayPitch )
-          && ( depthPitch == rhs.depthPitch );
-    }
-
-    bool operator!=( SubresourceLayout const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize offset;
-    DeviceSize size;
-    DeviceSize rowPitch;
-    DeviceSize arrayPitch;
-    DeviceSize depthPitch;
-  };
-  static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" );
-
-  struct BufferCopy
-  {
-    BufferCopy( DeviceSize srcOffset_ = 0,
-                DeviceSize dstOffset_ = 0,
-                DeviceSize size_ = 0 )
-      : srcOffset( srcOffset_ )
-      , dstOffset( dstOffset_ )
-      , size( size_ )
-    {
-    }
-
-    BufferCopy( VkBufferCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferCopy ) );
-    }
-
-    BufferCopy& operator=( VkBufferCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferCopy ) );
-      return *this;
-    }
-    BufferCopy& setSrcOffset( DeviceSize srcOffset_ )
-    {
-      srcOffset = srcOffset_;
-      return *this;
-    }
-
-    BufferCopy& setDstOffset( DeviceSize dstOffset_ )
-    {
-      dstOffset = dstOffset_;
-      return *this;
-    }
-
-    BufferCopy& setSize( DeviceSize size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    operator VkBufferCopy const&() const
-    {
-      return *reinterpret_cast<const VkBufferCopy*>(this);
-    }
-
-    operator VkBufferCopy &()
-    {
-      return *reinterpret_cast<VkBufferCopy*>(this);
-    }
-
-    bool operator==( BufferCopy const& rhs ) const
-    {
-      return ( srcOffset == rhs.srcOffset )
-          && ( dstOffset == rhs.dstOffset )
-          && ( size == rhs.size );
-    }
-
-    bool operator!=( BufferCopy const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize srcOffset;
-    DeviceSize dstOffset;
-    DeviceSize size;
-  };
-  static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" );
-
-  struct SpecializationMapEntry
-  {
-    SpecializationMapEntry( uint32_t constantID_ = 0,
-                            uint32_t offset_ = 0,
-                            size_t size_ = 0 )
-      : constantID( constantID_ )
-      , offset( offset_ )
-      , size( size_ )
-    {
-    }
-
-    SpecializationMapEntry( VkSpecializationMapEntry const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
-    }
-
-    SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
-      return *this;
-    }
-    SpecializationMapEntry& setConstantID( uint32_t constantID_ )
-    {
-      constantID = constantID_;
-      return *this;
-    }
-
-    SpecializationMapEntry& setOffset( uint32_t offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    SpecializationMapEntry& setSize( size_t size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    operator VkSpecializationMapEntry const&() const
-    {
-      return *reinterpret_cast<const VkSpecializationMapEntry*>(this);
-    }
-
-    operator VkSpecializationMapEntry &()
-    {
-      return *reinterpret_cast<VkSpecializationMapEntry*>(this);
-    }
-
-    bool operator==( SpecializationMapEntry const& rhs ) const
-    {
-      return ( constantID == rhs.constantID )
-          && ( offset == rhs.offset )
-          && ( size == rhs.size );
-    }
-
-    bool operator!=( SpecializationMapEntry const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t constantID;
-    uint32_t offset;
-    size_t size;
-  };
-  static_assert( sizeof( SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), "struct and wrapper have different size!" );
-
-  struct SpecializationInfo
-  {
-    SpecializationInfo( uint32_t mapEntryCount_ = 0,
-                        const SpecializationMapEntry* pMapEntries_ = nullptr,
-                        size_t dataSize_ = 0,
-                        const void* pData_ = nullptr )
-      : mapEntryCount( mapEntryCount_ )
-      , pMapEntries( pMapEntries_ )
-      , dataSize( dataSize_ )
-      , pData( pData_ )
-    {
-    }
-
-    SpecializationInfo( VkSpecializationInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SpecializationInfo ) );
-    }
-
-    SpecializationInfo& operator=( VkSpecializationInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SpecializationInfo ) );
-      return *this;
-    }
-    SpecializationInfo& setMapEntryCount( uint32_t mapEntryCount_ )
-    {
-      mapEntryCount = mapEntryCount_;
-      return *this;
-    }
-
-    SpecializationInfo& setPMapEntries( const SpecializationMapEntry* pMapEntries_ )
-    {
-      pMapEntries = pMapEntries_;
-      return *this;
-    }
-
-    SpecializationInfo& setDataSize( size_t dataSize_ )
-    {
-      dataSize = dataSize_;
-      return *this;
-    }
-
-    SpecializationInfo& setPData( const void* pData_ )
-    {
-      pData = pData_;
-      return *this;
-    }
-
-    operator VkSpecializationInfo const&() const
-    {
-      return *reinterpret_cast<const VkSpecializationInfo*>(this);
-    }
-
-    operator VkSpecializationInfo &()
-    {
-      return *reinterpret_cast<VkSpecializationInfo*>(this);
-    }
-
-    bool operator==( SpecializationInfo const& rhs ) const
-    {
-      return ( mapEntryCount == rhs.mapEntryCount )
-          && ( pMapEntries == rhs.pMapEntries )
-          && ( dataSize == rhs.dataSize )
-          && ( pData == rhs.pData );
-    }
-
-    bool operator!=( SpecializationInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t mapEntryCount;
-    const SpecializationMapEntry* pMapEntries;
-    size_t dataSize;
-    const void* pData;
-  };
-  static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" );
-
-  union ClearColorValue
-  {
-    ClearColorValue( const std::array<float,4>& float32_ = { {0} } )
-    {
-      memcpy( &float32, float32_.data(), 4 * sizeof( float ) );
-    }
-
-    ClearColorValue( const std::array<int32_t,4>& int32_ )
-    {
-      memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) );
-    }
-
-    ClearColorValue( const std::array<uint32_t,4>& uint32_ )
-    {
-      memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
-    }
-
-    ClearColorValue& setFloat32( std::array<float,4> float32_ )
-    {
-      memcpy( &float32, float32_.data(), 4 * sizeof( float ) );
-      return *this;
-    }
-
-    ClearColorValue& setInt32( std::array<int32_t,4> int32_ )
-    {
-      memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) );
-      return *this;
-    }
-
-    ClearColorValue& setUint32( std::array<uint32_t,4> uint32_ )
-    {
-      memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
-      return *this;
-    }
-
-    operator VkClearColorValue const&() const
-    {
-      return *reinterpret_cast<const VkClearColorValue*>(this);
-    }
-
-    operator VkClearColorValue &()
-    {
-      return *reinterpret_cast<VkClearColorValue*>(this);
-    }
-
-    float float32[4];
-    int32_t int32[4];
-    uint32_t uint32[4];
-  };
-
-  struct ClearDepthStencilValue
-  {
-    ClearDepthStencilValue( float depth_ = 0,
-                            uint32_t stencil_ = 0 )
-      : depth( depth_ )
-      , stencil( stencil_ )
-    {
-    }
-
-    ClearDepthStencilValue( VkClearDepthStencilValue const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
-    }
-
-    ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
-      return *this;
-    }
-    ClearDepthStencilValue& setDepth( float depth_ )
-    {
-      depth = depth_;
-      return *this;
-    }
-
-    ClearDepthStencilValue& setStencil( uint32_t stencil_ )
-    {
-      stencil = stencil_;
-      return *this;
-    }
-
-    operator VkClearDepthStencilValue const&() const
-    {
-      return *reinterpret_cast<const VkClearDepthStencilValue*>(this);
-    }
-
-    operator VkClearDepthStencilValue &()
-    {
-      return *reinterpret_cast<VkClearDepthStencilValue*>(this);
-    }
-
-    bool operator==( ClearDepthStencilValue const& rhs ) const
-    {
-      return ( depth == rhs.depth )
-          && ( stencil == rhs.stencil );
-    }
-
-    bool operator!=( ClearDepthStencilValue const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float depth;
-    uint32_t stencil;
-  };
-  static_assert( sizeof( ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), "struct and wrapper have different size!" );
-
-  union ClearValue
-  {
-    ClearValue( ClearColorValue color_ = ClearColorValue() )
-    {
-      color = color_;
-    }
-
-    ClearValue( ClearDepthStencilValue depthStencil_ )
-    {
-      depthStencil = depthStencil_;
-    }
-
-    ClearValue& setColor( ClearColorValue color_ )
-    {
-      color = color_;
-      return *this;
-    }
-
-    ClearValue& setDepthStencil( ClearDepthStencilValue depthStencil_ )
-    {
-      depthStencil = depthStencil_;
-      return *this;
-    }
-
-    operator VkClearValue const&() const
-    {
-      return *reinterpret_cast<const VkClearValue*>(this);
-    }
-
-    operator VkClearValue &()
-    {
-      return *reinterpret_cast<VkClearValue*>(this);
-    }
-
-#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-    ClearColorValue color;
-    ClearDepthStencilValue depthStencil;
-#else
-    VkClearColorValue color;
-    VkClearDepthStencilValue depthStencil;
-#endif  // VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-  };
-
-  struct PhysicalDeviceFeatures
-  {
-    PhysicalDeviceFeatures( Bool32 robustBufferAccess_ = 0,
-                            Bool32 fullDrawIndexUint32_ = 0,
-                            Bool32 imageCubeArray_ = 0,
-                            Bool32 independentBlend_ = 0,
-                            Bool32 geometryShader_ = 0,
-                            Bool32 tessellationShader_ = 0,
-                            Bool32 sampleRateShading_ = 0,
-                            Bool32 dualSrcBlend_ = 0,
-                            Bool32 logicOp_ = 0,
-                            Bool32 multiDrawIndirect_ = 0,
-                            Bool32 drawIndirectFirstInstance_ = 0,
-                            Bool32 depthClamp_ = 0,
-                            Bool32 depthBiasClamp_ = 0,
-                            Bool32 fillModeNonSolid_ = 0,
-                            Bool32 depthBounds_ = 0,
-                            Bool32 wideLines_ = 0,
-                            Bool32 largePoints_ = 0,
-                            Bool32 alphaToOne_ = 0,
-                            Bool32 multiViewport_ = 0,
-                            Bool32 samplerAnisotropy_ = 0,
-                            Bool32 textureCompressionETC2_ = 0,
-                            Bool32 textureCompressionASTC_LDR_ = 0,
-                            Bool32 textureCompressionBC_ = 0,
-                            Bool32 occlusionQueryPrecise_ = 0,
-                            Bool32 pipelineStatisticsQuery_ = 0,
-                            Bool32 vertexPipelineStoresAndAtomics_ = 0,
-                            Bool32 fragmentStoresAndAtomics_ = 0,
-                            Bool32 shaderTessellationAndGeometryPointSize_ = 0,
-                            Bool32 shaderImageGatherExtended_ = 0,
-                            Bool32 shaderStorageImageExtendedFormats_ = 0,
-                            Bool32 shaderStorageImageMultisample_ = 0,
-                            Bool32 shaderStorageImageReadWithoutFormat_ = 0,
-                            Bool32 shaderStorageImageWriteWithoutFormat_ = 0,
-                            Bool32 shaderUniformBufferArrayDynamicIndexing_ = 0,
-                            Bool32 shaderSampledImageArrayDynamicIndexing_ = 0,
-                            Bool32 shaderStorageBufferArrayDynamicIndexing_ = 0,
-                            Bool32 shaderStorageImageArrayDynamicIndexing_ = 0,
-                            Bool32 shaderClipDistance_ = 0,
-                            Bool32 shaderCullDistance_ = 0,
-                            Bool32 shaderFloat64_ = 0,
-                            Bool32 shaderInt64_ = 0,
-                            Bool32 shaderInt16_ = 0,
-                            Bool32 shaderResourceResidency_ = 0,
-                            Bool32 shaderResourceMinLod_ = 0,
-                            Bool32 sparseBinding_ = 0,
-                            Bool32 sparseResidencyBuffer_ = 0,
-                            Bool32 sparseResidencyImage2D_ = 0,
-                            Bool32 sparseResidencyImage3D_ = 0,
-                            Bool32 sparseResidency2Samples_ = 0,
-                            Bool32 sparseResidency4Samples_ = 0,
-                            Bool32 sparseResidency8Samples_ = 0,
-                            Bool32 sparseResidency16Samples_ = 0,
-                            Bool32 sparseResidencyAliased_ = 0,
-                            Bool32 variableMultisampleRate_ = 0,
-                            Bool32 inheritedQueries_ = 0 )
-      : robustBufferAccess( robustBufferAccess_ )
-      , fullDrawIndexUint32( fullDrawIndexUint32_ )
-      , imageCubeArray( imageCubeArray_ )
-      , independentBlend( independentBlend_ )
-      , geometryShader( geometryShader_ )
-      , tessellationShader( tessellationShader_ )
-      , sampleRateShading( sampleRateShading_ )
-      , dualSrcBlend( dualSrcBlend_ )
-      , logicOp( logicOp_ )
-      , multiDrawIndirect( multiDrawIndirect_ )
-      , drawIndirectFirstInstance( drawIndirectFirstInstance_ )
-      , depthClamp( depthClamp_ )
-      , depthBiasClamp( depthBiasClamp_ )
-      , fillModeNonSolid( fillModeNonSolid_ )
-      , depthBounds( depthBounds_ )
-      , wideLines( wideLines_ )
-      , largePoints( largePoints_ )
-      , alphaToOne( alphaToOne_ )
-      , multiViewport( multiViewport_ )
-      , samplerAnisotropy( samplerAnisotropy_ )
-      , textureCompressionETC2( textureCompressionETC2_ )
-      , textureCompressionASTC_LDR( textureCompressionASTC_LDR_ )
-      , textureCompressionBC( textureCompressionBC_ )
-      , occlusionQueryPrecise( occlusionQueryPrecise_ )
-      , pipelineStatisticsQuery( pipelineStatisticsQuery_ )
-      , vertexPipelineStoresAndAtomics( vertexPipelineStoresAndAtomics_ )
-      , fragmentStoresAndAtomics( fragmentStoresAndAtomics_ )
-      , shaderTessellationAndGeometryPointSize( shaderTessellationAndGeometryPointSize_ )
-      , shaderImageGatherExtended( shaderImageGatherExtended_ )
-      , shaderStorageImageExtendedFormats( shaderStorageImageExtendedFormats_ )
-      , shaderStorageImageMultisample( shaderStorageImageMultisample_ )
-      , shaderStorageImageReadWithoutFormat( shaderStorageImageReadWithoutFormat_ )
-      , shaderStorageImageWriteWithoutFormat( shaderStorageImageWriteWithoutFormat_ )
-      , shaderUniformBufferArrayDynamicIndexing( shaderUniformBufferArrayDynamicIndexing_ )
-      , shaderSampledImageArrayDynamicIndexing( shaderSampledImageArrayDynamicIndexing_ )
-      , shaderStorageBufferArrayDynamicIndexing( shaderStorageBufferArrayDynamicIndexing_ )
-      , shaderStorageImageArrayDynamicIndexing( shaderStorageImageArrayDynamicIndexing_ )
-      , shaderClipDistance( shaderClipDistance_ )
-      , shaderCullDistance( shaderCullDistance_ )
-      , shaderFloat64( shaderFloat64_ )
-      , shaderInt64( shaderInt64_ )
-      , shaderInt16( shaderInt16_ )
-      , shaderResourceResidency( shaderResourceResidency_ )
-      , shaderResourceMinLod( shaderResourceMinLod_ )
-      , sparseBinding( sparseBinding_ )
-      , sparseResidencyBuffer( sparseResidencyBuffer_ )
-      , sparseResidencyImage2D( sparseResidencyImage2D_ )
-      , sparseResidencyImage3D( sparseResidencyImage3D_ )
-      , sparseResidency2Samples( sparseResidency2Samples_ )
-      , sparseResidency4Samples( sparseResidency4Samples_ )
-      , sparseResidency8Samples( sparseResidency8Samples_ )
-      , sparseResidency16Samples( sparseResidency16Samples_ )
-      , sparseResidencyAliased( sparseResidencyAliased_ )
-      , variableMultisampleRate( variableMultisampleRate_ )
-      , inheritedQueries( inheritedQueries_ )
-    {
-    }
-
-    PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
-    }
-
-    PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
-      return *this;
-    }
-    PhysicalDeviceFeatures& setRobustBufferAccess( Bool32 robustBufferAccess_ )
-    {
-      robustBufferAccess = robustBufferAccess_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ )
-    {
-      fullDrawIndexUint32 = fullDrawIndexUint32_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setImageCubeArray( Bool32 imageCubeArray_ )
-    {
-      imageCubeArray = imageCubeArray_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setIndependentBlend( Bool32 independentBlend_ )
-    {
-      independentBlend = independentBlend_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setGeometryShader( Bool32 geometryShader_ )
-    {
-      geometryShader = geometryShader_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setTessellationShader( Bool32 tessellationShader_ )
-    {
-      tessellationShader = tessellationShader_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSampleRateShading( Bool32 sampleRateShading_ )
-    {
-      sampleRateShading = sampleRateShading_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDualSrcBlend( Bool32 dualSrcBlend_ )
-    {
-      dualSrcBlend = dualSrcBlend_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setLogicOp( Bool32 logicOp_ )
-    {
-      logicOp = logicOp_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setMultiDrawIndirect( Bool32 multiDrawIndirect_ )
-    {
-      multiDrawIndirect = multiDrawIndirect_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ )
-    {
-      drawIndirectFirstInstance = drawIndirectFirstInstance_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDepthClamp( Bool32 depthClamp_ )
-    {
-      depthClamp = depthClamp_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDepthBiasClamp( Bool32 depthBiasClamp_ )
-    {
-      depthBiasClamp = depthBiasClamp_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setFillModeNonSolid( Bool32 fillModeNonSolid_ )
-    {
-      fillModeNonSolid = fillModeNonSolid_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDepthBounds( Bool32 depthBounds_ )
-    {
-      depthBounds = depthBounds_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setWideLines( Bool32 wideLines_ )
-    {
-      wideLines = wideLines_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setLargePoints( Bool32 largePoints_ )
-    {
-      largePoints = largePoints_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setAlphaToOne( Bool32 alphaToOne_ )
-    {
-      alphaToOne = alphaToOne_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setMultiViewport( Bool32 multiViewport_ )
-    {
-      multiViewport = multiViewport_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSamplerAnisotropy( Bool32 samplerAnisotropy_ )
-    {
-      samplerAnisotropy = samplerAnisotropy_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setTextureCompressionETC2( Bool32 textureCompressionETC2_ )
-    {
-      textureCompressionETC2 = textureCompressionETC2_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ )
-    {
-      textureCompressionASTC_LDR = textureCompressionASTC_LDR_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setTextureCompressionBC( Bool32 textureCompressionBC_ )
-    {
-      textureCompressionBC = textureCompressionBC_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ )
-    {
-      occlusionQueryPrecise = occlusionQueryPrecise_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ )
-    {
-      pipelineStatisticsQuery = pipelineStatisticsQuery_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ )
-    {
-      vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ )
-    {
-      fragmentStoresAndAtomics = fragmentStoresAndAtomics_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ )
-    {
-      shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ )
-    {
-      shaderImageGatherExtended = shaderImageGatherExtended_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ )
-    {
-      shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ )
-    {
-      shaderStorageImageMultisample = shaderStorageImageMultisample_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ )
-    {
-      shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ )
-    {
-      shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ )
-    {
-      shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ )
-    {
-      shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ )
-    {
-      shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ )
-    {
-      shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderClipDistance( Bool32 shaderClipDistance_ )
-    {
-      shaderClipDistance = shaderClipDistance_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderCullDistance( Bool32 shaderCullDistance_ )
-    {
-      shaderCullDistance = shaderCullDistance_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderFloat64( Bool32 shaderFloat64_ )
-    {
-      shaderFloat64 = shaderFloat64_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderInt64( Bool32 shaderInt64_ )
-    {
-      shaderInt64 = shaderInt64_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderInt16( Bool32 shaderInt16_ )
-    {
-      shaderInt16 = shaderInt16_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderResourceResidency( Bool32 shaderResourceResidency_ )
-    {
-      shaderResourceResidency = shaderResourceResidency_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderResourceMinLod( Bool32 shaderResourceMinLod_ )
-    {
-      shaderResourceMinLod = shaderResourceMinLod_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseBinding( Bool32 sparseBinding_ )
-    {
-      sparseBinding = sparseBinding_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ )
-    {
-      sparseResidencyBuffer = sparseResidencyBuffer_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ )
-    {
-      sparseResidencyImage2D = sparseResidencyImage2D_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ )
-    {
-      sparseResidencyImage3D = sparseResidencyImage3D_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidency2Samples( Bool32 sparseResidency2Samples_ )
-    {
-      sparseResidency2Samples = sparseResidency2Samples_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidency4Samples( Bool32 sparseResidency4Samples_ )
-    {
-      sparseResidency4Samples = sparseResidency4Samples_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidency8Samples( Bool32 sparseResidency8Samples_ )
-    {
-      sparseResidency8Samples = sparseResidency8Samples_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidency16Samples( Bool32 sparseResidency16Samples_ )
-    {
-      sparseResidency16Samples = sparseResidency16Samples_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidencyAliased( Bool32 sparseResidencyAliased_ )
-    {
-      sparseResidencyAliased = sparseResidencyAliased_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setVariableMultisampleRate( Bool32 variableMultisampleRate_ )
-    {
-      variableMultisampleRate = variableMultisampleRate_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setInheritedQueries( Bool32 inheritedQueries_ )
-    {
-      inheritedQueries = inheritedQueries_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceFeatures const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceFeatures*>(this);
-    }
-
-    operator VkPhysicalDeviceFeatures &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceFeatures*>(this);
-    }
-
-    bool operator==( PhysicalDeviceFeatures const& rhs ) const
-    {
-      return ( robustBufferAccess == rhs.robustBufferAccess )
-          && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 )
-          && ( imageCubeArray == rhs.imageCubeArray )
-          && ( independentBlend == rhs.independentBlend )
-          && ( geometryShader == rhs.geometryShader )
-          && ( tessellationShader == rhs.tessellationShader )
-          && ( sampleRateShading == rhs.sampleRateShading )
-          && ( dualSrcBlend == rhs.dualSrcBlend )
-          && ( logicOp == rhs.logicOp )
-          && ( multiDrawIndirect == rhs.multiDrawIndirect )
-          && ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance )
-          && ( depthClamp == rhs.depthClamp )
-          && ( depthBiasClamp == rhs.depthBiasClamp )
-          && ( fillModeNonSolid == rhs.fillModeNonSolid )
-          && ( depthBounds == rhs.depthBounds )
-          && ( wideLines == rhs.wideLines )
-          && ( largePoints == rhs.largePoints )
-          && ( alphaToOne == rhs.alphaToOne )
-          && ( multiViewport == rhs.multiViewport )
-          && ( samplerAnisotropy == rhs.samplerAnisotropy )
-          && ( textureCompressionETC2 == rhs.textureCompressionETC2 )
-          && ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR )
-          && ( textureCompressionBC == rhs.textureCompressionBC )
-          && ( occlusionQueryPrecise == rhs.occlusionQueryPrecise )
-          && ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery )
-          && ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics )
-          && ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics )
-          && ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize )
-          && ( shaderImageGatherExtended == rhs.shaderImageGatherExtended )
-          && ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats )
-          && ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample )
-          && ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat )
-          && ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat )
-          && ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing )
-          && ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing )
-          && ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing )
-          && ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing )
-          && ( shaderClipDistance == rhs.shaderClipDistance )
-          && ( shaderCullDistance == rhs.shaderCullDistance )
-          && ( shaderFloat64 == rhs.shaderFloat64 )
-          && ( shaderInt64 == rhs.shaderInt64 )
-          && ( shaderInt16 == rhs.shaderInt16 )
-          && ( shaderResourceResidency == rhs.shaderResourceResidency )
-          && ( shaderResourceMinLod == rhs.shaderResourceMinLod )
-          && ( sparseBinding == rhs.sparseBinding )
-          && ( sparseResidencyBuffer == rhs.sparseResidencyBuffer )
-          && ( sparseResidencyImage2D == rhs.sparseResidencyImage2D )
-          && ( sparseResidencyImage3D == rhs.sparseResidencyImage3D )
-          && ( sparseResidency2Samples == rhs.sparseResidency2Samples )
-          && ( sparseResidency4Samples == rhs.sparseResidency4Samples )
-          && ( sparseResidency8Samples == rhs.sparseResidency8Samples )
-          && ( sparseResidency16Samples == rhs.sparseResidency16Samples )
-          && ( sparseResidencyAliased == rhs.sparseResidencyAliased )
-          && ( variableMultisampleRate == rhs.variableMultisampleRate )
-          && ( inheritedQueries == rhs.inheritedQueries );
-    }
-
-    bool operator!=( PhysicalDeviceFeatures const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Bool32 robustBufferAccess;
-    Bool32 fullDrawIndexUint32;
-    Bool32 imageCubeArray;
-    Bool32 independentBlend;
-    Bool32 geometryShader;
-    Bool32 tessellationShader;
-    Bool32 sampleRateShading;
-    Bool32 dualSrcBlend;
-    Bool32 logicOp;
-    Bool32 multiDrawIndirect;
-    Bool32 drawIndirectFirstInstance;
-    Bool32 depthClamp;
-    Bool32 depthBiasClamp;
-    Bool32 fillModeNonSolid;
-    Bool32 depthBounds;
-    Bool32 wideLines;
-    Bool32 largePoints;
-    Bool32 alphaToOne;
-    Bool32 multiViewport;
-    Bool32 samplerAnisotropy;
-    Bool32 textureCompressionETC2;
-    Bool32 textureCompressionASTC_LDR;
-    Bool32 textureCompressionBC;
-    Bool32 occlusionQueryPrecise;
-    Bool32 pipelineStatisticsQuery;
-    Bool32 vertexPipelineStoresAndAtomics;
-    Bool32 fragmentStoresAndAtomics;
-    Bool32 shaderTessellationAndGeometryPointSize;
-    Bool32 shaderImageGatherExtended;
-    Bool32 shaderStorageImageExtendedFormats;
-    Bool32 shaderStorageImageMultisample;
-    Bool32 shaderStorageImageReadWithoutFormat;
-    Bool32 shaderStorageImageWriteWithoutFormat;
-    Bool32 shaderUniformBufferArrayDynamicIndexing;
-    Bool32 shaderSampledImageArrayDynamicIndexing;
-    Bool32 shaderStorageBufferArrayDynamicIndexing;
-    Bool32 shaderStorageImageArrayDynamicIndexing;
-    Bool32 shaderClipDistance;
-    Bool32 shaderCullDistance;
-    Bool32 shaderFloat64;
-    Bool32 shaderInt64;
-    Bool32 shaderInt16;
-    Bool32 shaderResourceResidency;
-    Bool32 shaderResourceMinLod;
-    Bool32 sparseBinding;
-    Bool32 sparseResidencyBuffer;
-    Bool32 sparseResidencyImage2D;
-    Bool32 sparseResidencyImage3D;
-    Bool32 sparseResidency2Samples;
-    Bool32 sparseResidency4Samples;
-    Bool32 sparseResidency8Samples;
-    Bool32 sparseResidency16Samples;
-    Bool32 sparseResidencyAliased;
-    Bool32 variableMultisampleRate;
-    Bool32 inheritedQueries;
-  };
-  static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceSparseProperties
-  {
-    operator VkPhysicalDeviceSparseProperties const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceSparseProperties*>(this);
-    }
-
-    operator VkPhysicalDeviceSparseProperties &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceSparseProperties*>(this);
-    }
-
-    bool operator==( PhysicalDeviceSparseProperties const& rhs ) const
-    {
-      return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape )
-          && ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape )
-          && ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape )
-          && ( residencyAlignedMipSize == rhs.residencyAlignedMipSize )
-          && ( residencyNonResidentStrict == rhs.residencyNonResidentStrict );
-    }
-
-    bool operator!=( PhysicalDeviceSparseProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Bool32 residencyStandard2DBlockShape;
-    Bool32 residencyStandard2DMultisampleBlockShape;
-    Bool32 residencyStandard3DBlockShape;
-    Bool32 residencyAlignedMipSize;
-    Bool32 residencyNonResidentStrict;
-  };
-  static_assert( sizeof( PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), "struct and wrapper have different size!" );
-
-  struct DrawIndirectCommand
-  {
-    DrawIndirectCommand( uint32_t vertexCount_ = 0,
-                         uint32_t instanceCount_ = 0,
-                         uint32_t firstVertex_ = 0,
-                         uint32_t firstInstance_ = 0 )
-      : vertexCount( vertexCount_ )
-      , instanceCount( instanceCount_ )
-      , firstVertex( firstVertex_ )
-      , firstInstance( firstInstance_ )
-    {
-    }
-
-    DrawIndirectCommand( VkDrawIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
-    }
-
-    DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
-      return *this;
-    }
-    DrawIndirectCommand& setVertexCount( uint32_t vertexCount_ )
-    {
-      vertexCount = vertexCount_;
-      return *this;
-    }
-
-    DrawIndirectCommand& setInstanceCount( uint32_t instanceCount_ )
-    {
-      instanceCount = instanceCount_;
-      return *this;
-    }
-
-    DrawIndirectCommand& setFirstVertex( uint32_t firstVertex_ )
-    {
-      firstVertex = firstVertex_;
-      return *this;
-    }
-
-    DrawIndirectCommand& setFirstInstance( uint32_t firstInstance_ )
-    {
-      firstInstance = firstInstance_;
-      return *this;
-    }
-
-    operator VkDrawIndirectCommand const&() const
-    {
-      return *reinterpret_cast<const VkDrawIndirectCommand*>(this);
-    }
-
-    operator VkDrawIndirectCommand &()
-    {
-      return *reinterpret_cast<VkDrawIndirectCommand*>(this);
-    }
-
-    bool operator==( DrawIndirectCommand const& rhs ) const
-    {
-      return ( vertexCount == rhs.vertexCount )
-          && ( instanceCount == rhs.instanceCount )
-          && ( firstVertex == rhs.firstVertex )
-          && ( firstInstance == rhs.firstInstance );
-    }
-
-    bool operator!=( DrawIndirectCommand const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t vertexCount;
-    uint32_t instanceCount;
-    uint32_t firstVertex;
-    uint32_t firstInstance;
-  };
-  static_assert( sizeof( DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" );
-
-  struct DrawIndexedIndirectCommand
-  {
-    DrawIndexedIndirectCommand( uint32_t indexCount_ = 0,
-                                uint32_t instanceCount_ = 0,
-                                uint32_t firstIndex_ = 0,
-                                int32_t vertexOffset_ = 0,
-                                uint32_t firstInstance_ = 0 )
-      : indexCount( indexCount_ )
-      , instanceCount( instanceCount_ )
-      , firstIndex( firstIndex_ )
-      , vertexOffset( vertexOffset_ )
-      , firstInstance( firstInstance_ )
-    {
-    }
-
-    DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
-    }
-
-    DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
-      return *this;
-    }
-    DrawIndexedIndirectCommand& setIndexCount( uint32_t indexCount_ )
-    {
-      indexCount = indexCount_;
-      return *this;
-    }
-
-    DrawIndexedIndirectCommand& setInstanceCount( uint32_t instanceCount_ )
-    {
-      instanceCount = instanceCount_;
-      return *this;
-    }
-
-    DrawIndexedIndirectCommand& setFirstIndex( uint32_t firstIndex_ )
-    {
-      firstIndex = firstIndex_;
-      return *this;
-    }
-
-    DrawIndexedIndirectCommand& setVertexOffset( int32_t vertexOffset_ )
-    {
-      vertexOffset = vertexOffset_;
-      return *this;
-    }
-
-    DrawIndexedIndirectCommand& setFirstInstance( uint32_t firstInstance_ )
-    {
-      firstInstance = firstInstance_;
-      return *this;
-    }
-
-    operator VkDrawIndexedIndirectCommand const&() const
-    {
-      return *reinterpret_cast<const VkDrawIndexedIndirectCommand*>(this);
-    }
-
-    operator VkDrawIndexedIndirectCommand &()
-    {
-      return *reinterpret_cast<VkDrawIndexedIndirectCommand*>(this);
-    }
-
-    bool operator==( DrawIndexedIndirectCommand const& rhs ) const
-    {
-      return ( indexCount == rhs.indexCount )
-          && ( instanceCount == rhs.instanceCount )
-          && ( firstIndex == rhs.firstIndex )
-          && ( vertexOffset == rhs.vertexOffset )
-          && ( firstInstance == rhs.firstInstance );
-    }
-
-    bool operator!=( DrawIndexedIndirectCommand const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t indexCount;
-    uint32_t instanceCount;
-    uint32_t firstIndex;
-    int32_t vertexOffset;
-    uint32_t firstInstance;
-  };
-  static_assert( sizeof( DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), "struct and wrapper have different size!" );
-
-  struct DispatchIndirectCommand
-  {
-    DispatchIndirectCommand( uint32_t x_ = 0,
-                             uint32_t y_ = 0,
-                             uint32_t z_ = 0 )
-      : x( x_ )
-      , y( y_ )
-      , z( z_ )
-    {
-    }
-
-    DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
-    }
-
-    DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
-      return *this;
-    }
-    DispatchIndirectCommand& setX( uint32_t x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    DispatchIndirectCommand& setY( uint32_t y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    DispatchIndirectCommand& setZ( uint32_t z_ )
-    {
-      z = z_;
-      return *this;
-    }
-
-    operator VkDispatchIndirectCommand const&() const
-    {
-      return *reinterpret_cast<const VkDispatchIndirectCommand*>(this);
-    }
-
-    operator VkDispatchIndirectCommand &()
-    {
-      return *reinterpret_cast<VkDispatchIndirectCommand*>(this);
-    }
-
-    bool operator==( DispatchIndirectCommand const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y )
-          && ( z == rhs.z );
-    }
-
-    bool operator!=( DispatchIndirectCommand const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t x;
-    uint32_t y;
-    uint32_t z;
-  };
-  static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" );
-
-  struct DisplayPlanePropertiesKHR
-  {
-    operator VkDisplayPlanePropertiesKHR const&() const
-    {
-      return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>(this);
-    }
-
-    operator VkDisplayPlanePropertiesKHR &()
-    {
-      return *reinterpret_cast<VkDisplayPlanePropertiesKHR*>(this);
-    }
-
-    bool operator==( DisplayPlanePropertiesKHR const& rhs ) const
-    {
-      return ( currentDisplay == rhs.currentDisplay )
-          && ( currentStackIndex == rhs.currentStackIndex );
-    }
-
-    bool operator!=( DisplayPlanePropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DisplayKHR currentDisplay;
-    uint32_t currentStackIndex;
-  };
-  static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" );
-
-  struct DisplayModeParametersKHR
-  {
-    DisplayModeParametersKHR( Extent2D visibleRegion_ = Extent2D(),
-                              uint32_t refreshRate_ = 0 )
-      : visibleRegion( visibleRegion_ )
-      , refreshRate( refreshRate_ )
-    {
-    }
-
-    DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
-    }
-
-    DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
-      return *this;
-    }
-    DisplayModeParametersKHR& setVisibleRegion( Extent2D visibleRegion_ )
-    {
-      visibleRegion = visibleRegion_;
-      return *this;
-    }
-
-    DisplayModeParametersKHR& setRefreshRate( uint32_t refreshRate_ )
-    {
-      refreshRate = refreshRate_;
-      return *this;
-    }
-
-    operator VkDisplayModeParametersKHR const&() const
-    {
-      return *reinterpret_cast<const VkDisplayModeParametersKHR*>(this);
-    }
-
-    operator VkDisplayModeParametersKHR &()
-    {
-      return *reinterpret_cast<VkDisplayModeParametersKHR*>(this);
-    }
-
-    bool operator==( DisplayModeParametersKHR const& rhs ) const
-    {
-      return ( visibleRegion == rhs.visibleRegion )
-          && ( refreshRate == rhs.refreshRate );
-    }
-
-    bool operator!=( DisplayModeParametersKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Extent2D visibleRegion;
-    uint32_t refreshRate;
-  };
-  static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" );
-
-  struct DisplayModePropertiesKHR
-  {
-    operator VkDisplayModePropertiesKHR const&() const
-    {
-      return *reinterpret_cast<const VkDisplayModePropertiesKHR*>(this);
-    }
-
-    operator VkDisplayModePropertiesKHR &()
-    {
-      return *reinterpret_cast<VkDisplayModePropertiesKHR*>(this);
-    }
-
-    bool operator==( DisplayModePropertiesKHR const& rhs ) const
-    {
-      return ( displayMode == rhs.displayMode )
-          && ( parameters == rhs.parameters );
-    }
-
-    bool operator!=( DisplayModePropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DisplayModeKHR displayMode;
-    DisplayModeParametersKHR parameters;
-  };
-  static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" );
-
-  struct ConformanceVersionKHR
-  {
-    ConformanceVersionKHR( uint8_t major_ = 0,
-                           uint8_t minor_ = 0,
-                           uint8_t subminor_ = 0,
-                           uint8_t patch_ = 0 )
-      : major( major_ )
-      , minor( minor_ )
-      , subminor( subminor_ )
-      , patch( patch_ )
-    {
-    }
-
-    ConformanceVersionKHR( VkConformanceVersionKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) );
-    }
-
-    ConformanceVersionKHR& operator=( VkConformanceVersionKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) );
-      return *this;
-    }
-    ConformanceVersionKHR& setMajor( uint8_t major_ )
-    {
-      major = major_;
-      return *this;
-    }
-
-    ConformanceVersionKHR& setMinor( uint8_t minor_ )
-    {
-      minor = minor_;
-      return *this;
-    }
-
-    ConformanceVersionKHR& setSubminor( uint8_t subminor_ )
-    {
-      subminor = subminor_;
-      return *this;
-    }
-
-    ConformanceVersionKHR& setPatch( uint8_t patch_ )
-    {
-      patch = patch_;
-      return *this;
-    }
-
-    operator VkConformanceVersionKHR const&() const
-    {
-      return *reinterpret_cast<const VkConformanceVersionKHR*>(this);
-    }
-
-    operator VkConformanceVersionKHR &()
-    {
-      return *reinterpret_cast<VkConformanceVersionKHR*>(this);
-    }
-
-    bool operator==( ConformanceVersionKHR const& rhs ) const
-    {
-      return ( major == rhs.major )
-          && ( minor == rhs.minor )
-          && ( subminor == rhs.subminor )
-          && ( patch == rhs.patch );
-    }
-
-    bool operator!=( ConformanceVersionKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint8_t major;
-    uint8_t minor;
-    uint8_t subminor;
-    uint8_t patch;
-  };
-  static_assert( sizeof( ConformanceVersionKHR ) == sizeof( VkConformanceVersionKHR ), "struct and wrapper have different size!" );
-
-  struct RectLayerKHR
-  {
-    RectLayerKHR( Offset2D offset_ = Offset2D(),
-                  Extent2D extent_ = Extent2D(),
-                  uint32_t layer_ = 0 )
-      : offset( offset_ )
-      , extent( extent_ )
-      , layer( layer_ )
-    {
-    }
-
-    explicit RectLayerKHR( Rect2D const& rect2D,
-                           uint32_t layer_ = 0 )
-      : offset( rect2D.offset )
-      , extent( rect2D.extent )
-      , layer( layer_ )
-    {}
-
-    RectLayerKHR( VkRectLayerKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RectLayerKHR ) );
-    }
-
-    RectLayerKHR& operator=( VkRectLayerKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RectLayerKHR ) );
-      return *this;
-    }
-    RectLayerKHR& setOffset( Offset2D offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    RectLayerKHR& setExtent( Extent2D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    RectLayerKHR& setLayer( uint32_t layer_ )
-    {
-      layer = layer_;
-      return *this;
-    }
-
-    operator VkRectLayerKHR const&() const
-    {
-      return *reinterpret_cast<const VkRectLayerKHR*>(this);
-    }
-
-    operator VkRectLayerKHR &()
-    {
-      return *reinterpret_cast<VkRectLayerKHR*>(this);
-    }
-
-    bool operator==( RectLayerKHR const& rhs ) const
-    {
-      return ( offset == rhs.offset )
-          && ( extent == rhs.extent )
-          && ( layer == rhs.layer );
-    }
-
-    bool operator!=( RectLayerKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Offset2D offset;
-    Extent2D extent;
-    uint32_t layer;
-  };
-  static_assert( sizeof( RectLayerKHR ) == sizeof( VkRectLayerKHR ), "struct and wrapper have different size!" );
-
-  struct PresentRegionKHR
-  {
-    PresentRegionKHR( uint32_t rectangleCount_ = 0,
-                      const RectLayerKHR* pRectangles_ = nullptr )
-      : rectangleCount( rectangleCount_ )
-      , pRectangles( pRectangles_ )
-    {
-    }
-
-    PresentRegionKHR( VkPresentRegionKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
-    }
-
-    PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
-      return *this;
-    }
-    PresentRegionKHR& setRectangleCount( uint32_t rectangleCount_ )
-    {
-      rectangleCount = rectangleCount_;
-      return *this;
-    }
-
-    PresentRegionKHR& setPRectangles( const RectLayerKHR* pRectangles_ )
-    {
-      pRectangles = pRectangles_;
-      return *this;
-    }
-
-    operator VkPresentRegionKHR const&() const
-    {
-      return *reinterpret_cast<const VkPresentRegionKHR*>(this);
-    }
-
-    operator VkPresentRegionKHR &()
-    {
-      return *reinterpret_cast<VkPresentRegionKHR*>(this);
-    }
-
-    bool operator==( PresentRegionKHR const& rhs ) const
-    {
-      return ( rectangleCount == rhs.rectangleCount )
-          && ( pRectangles == rhs.pRectangles );
-    }
-
-    bool operator!=( PresentRegionKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t rectangleCount;
-    const RectLayerKHR* pRectangles;
-  };
-  static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" );
-
-  struct XYColorEXT
-  {
-    XYColorEXT( float x_ = 0,
-                float y_ = 0 )
-      : x( x_ )
-      , y( y_ )
-    {
-    }
-
-    XYColorEXT( VkXYColorEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XYColorEXT ) );
-    }
-
-    XYColorEXT& operator=( VkXYColorEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XYColorEXT ) );
-      return *this;
-    }
-    XYColorEXT& setX( float x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    XYColorEXT& setY( float y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    operator VkXYColorEXT const&() const
-    {
-      return *reinterpret_cast<const VkXYColorEXT*>(this);
-    }
-
-    operator VkXYColorEXT &()
-    {
-      return *reinterpret_cast<VkXYColorEXT*>(this);
-    }
-
-    bool operator==( XYColorEXT const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y );
-    }
-
-    bool operator!=( XYColorEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float x;
-    float y;
-  };
-  static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" );
-
-  struct RefreshCycleDurationGOOGLE
-  {
-    operator VkRefreshCycleDurationGOOGLE const&() const
-    {
-      return *reinterpret_cast<const VkRefreshCycleDurationGOOGLE*>(this);
-    }
-
-    operator VkRefreshCycleDurationGOOGLE &()
-    {
-      return *reinterpret_cast<VkRefreshCycleDurationGOOGLE*>(this);
-    }
-
-    bool operator==( RefreshCycleDurationGOOGLE const& rhs ) const
-    {
-      return ( refreshDuration == rhs.refreshDuration );
-    }
-
-    bool operator!=( RefreshCycleDurationGOOGLE const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint64_t refreshDuration;
-  };
-  static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" );
-
-  struct PastPresentationTimingGOOGLE
-  {
-    operator VkPastPresentationTimingGOOGLE const&() const
-    {
-      return *reinterpret_cast<const VkPastPresentationTimingGOOGLE*>(this);
-    }
-
-    operator VkPastPresentationTimingGOOGLE &()
-    {
-      return *reinterpret_cast<VkPastPresentationTimingGOOGLE*>(this);
-    }
-
-    bool operator==( PastPresentationTimingGOOGLE const& rhs ) const
-    {
-      return ( presentID == rhs.presentID )
-          && ( desiredPresentTime == rhs.desiredPresentTime )
-          && ( actualPresentTime == rhs.actualPresentTime )
-          && ( earliestPresentTime == rhs.earliestPresentTime )
-          && ( presentMargin == rhs.presentMargin );
-    }
-
-    bool operator!=( PastPresentationTimingGOOGLE const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t presentID;
-    uint64_t desiredPresentTime;
-    uint64_t actualPresentTime;
-    uint64_t earliestPresentTime;
-    uint64_t presentMargin;
-  };
-  static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" );
-
-  struct PresentTimeGOOGLE
-  {
-    PresentTimeGOOGLE( uint32_t presentID_ = 0,
-                       uint64_t desiredPresentTime_ = 0 )
-      : presentID( presentID_ )
-      , desiredPresentTime( desiredPresentTime_ )
-    {
-    }
-
-    PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
-    }
-
-    PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
-      return *this;
-    }
-    PresentTimeGOOGLE& setPresentID( uint32_t presentID_ )
-    {
-      presentID = presentID_;
-      return *this;
-    }
-
-    PresentTimeGOOGLE& setDesiredPresentTime( uint64_t desiredPresentTime_ )
-    {
-      desiredPresentTime = desiredPresentTime_;
-      return *this;
-    }
-
-    operator VkPresentTimeGOOGLE const&() const
-    {
-      return *reinterpret_cast<const VkPresentTimeGOOGLE*>(this);
-    }
-
-    operator VkPresentTimeGOOGLE &()
-    {
-      return *reinterpret_cast<VkPresentTimeGOOGLE*>(this);
-    }
-
-    bool operator==( PresentTimeGOOGLE const& rhs ) const
-    {
-      return ( presentID == rhs.presentID )
-          && ( desiredPresentTime == rhs.desiredPresentTime );
-    }
-
-    bool operator!=( PresentTimeGOOGLE const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t presentID;
-    uint64_t desiredPresentTime;
-  };
-  static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" );
-
-  struct ViewportWScalingNV
-  {
-    ViewportWScalingNV( float xcoeff_ = 0,
-                        float ycoeff_ = 0 )
-      : xcoeff( xcoeff_ )
-      , ycoeff( ycoeff_ )
-    {
-    }
-
-    ViewportWScalingNV( VkViewportWScalingNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
-    }
-
-    ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
-      return *this;
-    }
-    ViewportWScalingNV& setXcoeff( float xcoeff_ )
-    {
-      xcoeff = xcoeff_;
-      return *this;
-    }
-
-    ViewportWScalingNV& setYcoeff( float ycoeff_ )
-    {
-      ycoeff = ycoeff_;
-      return *this;
-    }
-
-    operator VkViewportWScalingNV const&() const
-    {
-      return *reinterpret_cast<const VkViewportWScalingNV*>(this);
-    }
-
-    operator VkViewportWScalingNV &()
-    {
-      return *reinterpret_cast<VkViewportWScalingNV*>(this);
-    }
-
-    bool operator==( ViewportWScalingNV const& rhs ) const
-    {
-      return ( xcoeff == rhs.xcoeff )
-          && ( ycoeff == rhs.ycoeff );
-    }
-
-    bool operator!=( ViewportWScalingNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float xcoeff;
-    float ycoeff;
-  };
-  static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" );
-
-  struct SampleLocationEXT
-  {
-    SampleLocationEXT( float x_ = 0,
-                       float y_ = 0 )
-      : x( x_ )
-      , y( y_ )
-    {
-    }
-
-    SampleLocationEXT( VkSampleLocationEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SampleLocationEXT ) );
-    }
-
-    SampleLocationEXT& operator=( VkSampleLocationEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SampleLocationEXT ) );
-      return *this;
-    }
-    SampleLocationEXT& setX( float x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    SampleLocationEXT& setY( float y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    operator VkSampleLocationEXT const&() const
-    {
-      return *reinterpret_cast<const VkSampleLocationEXT*>(this);
-    }
-
-    operator VkSampleLocationEXT &()
-    {
-      return *reinterpret_cast<VkSampleLocationEXT*>(this);
-    }
-
-    bool operator==( SampleLocationEXT const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y );
-    }
-
-    bool operator!=( SampleLocationEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float x;
-    float y;
-  };
-  static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" );
-
-  struct ShaderResourceUsageAMD
-  {
-    operator VkShaderResourceUsageAMD const&() const
-    {
-      return *reinterpret_cast<const VkShaderResourceUsageAMD*>(this);
-    }
-
-    operator VkShaderResourceUsageAMD &()
-    {
-      return *reinterpret_cast<VkShaderResourceUsageAMD*>(this);
-    }
-
-    bool operator==( ShaderResourceUsageAMD const& rhs ) const
-    {
-      return ( numUsedVgprs == rhs.numUsedVgprs )
-          && ( numUsedSgprs == rhs.numUsedSgprs )
-          && ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup )
-          && ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes )
-          && ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes );
-    }
-
-    bool operator!=( ShaderResourceUsageAMD const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t numUsedVgprs;
-    uint32_t numUsedSgprs;
-    uint32_t ldsSizePerLocalWorkGroup;
-    size_t ldsUsageSizeInBytes;
-    size_t scratchMemUsageInBytes;
-  };
-  static_assert( sizeof( ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), "struct and wrapper have different size!" );
-
-  struct VertexInputBindingDivisorDescriptionEXT
-  {
-    VertexInputBindingDivisorDescriptionEXT( uint32_t binding_ = 0,
-                                             uint32_t divisor_ = 0 )
-      : binding( binding_ )
-      , divisor( divisor_ )
-    {
-    }
-
-    VertexInputBindingDivisorDescriptionEXT( VkVertexInputBindingDivisorDescriptionEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) );
-    }
-
-    VertexInputBindingDivisorDescriptionEXT& operator=( VkVertexInputBindingDivisorDescriptionEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) );
-      return *this;
-    }
-    VertexInputBindingDivisorDescriptionEXT& setBinding( uint32_t binding_ )
-    {
-      binding = binding_;
-      return *this;
-    }
-
-    VertexInputBindingDivisorDescriptionEXT& setDivisor( uint32_t divisor_ )
-    {
-      divisor = divisor_;
-      return *this;
-    }
-
-    operator VkVertexInputBindingDivisorDescriptionEXT const&() const
-    {
-      return *reinterpret_cast<const VkVertexInputBindingDivisorDescriptionEXT*>(this);
-    }
-
-    operator VkVertexInputBindingDivisorDescriptionEXT &()
-    {
-      return *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>(this);
-    }
-
-    bool operator==( VertexInputBindingDivisorDescriptionEXT const& rhs ) const
-    {
-      return ( binding == rhs.binding )
-          && ( divisor == rhs.divisor );
-    }
-
-    bool operator!=( VertexInputBindingDivisorDescriptionEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t binding;
-    uint32_t divisor;
-  };
-  static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" );
-
-  struct CoarseSampleLocationNV
+  enum class AccelerationStructureMemoryRequirementsTypeNV
   {
-    CoarseSampleLocationNV( uint32_t pixelX_ = 0,
-                            uint32_t pixelY_ = 0,
-                            uint32_t sample_ = 0 )
-      : pixelX( pixelX_ )
-      , pixelY( pixelY_ )
-      , sample( sample_ )
-    {
-    }
-
-    CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
-    }
-
-    CoarseSampleLocationNV& operator=( VkCoarseSampleLocationNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
-      return *this;
-    }
-    CoarseSampleLocationNV& setPixelX( uint32_t pixelX_ )
-    {
-      pixelX = pixelX_;
-      return *this;
-    }
-
-    CoarseSampleLocationNV& setPixelY( uint32_t pixelY_ )
-    {
-      pixelY = pixelY_;
-      return *this;
-    }
-
-    CoarseSampleLocationNV& setSample( uint32_t sample_ )
-    {
-      sample = sample_;
-      return *this;
-    }
-
-    operator VkCoarseSampleLocationNV const&() const
-    {
-      return *reinterpret_cast<const VkCoarseSampleLocationNV*>(this);
-    }
-
-    operator VkCoarseSampleLocationNV &()
-    {
-      return *reinterpret_cast<VkCoarseSampleLocationNV*>(this);
-    }
-
-    bool operator==( CoarseSampleLocationNV const& rhs ) const
-    {
-      return ( pixelX == rhs.pixelX )
-          && ( pixelY == rhs.pixelY )
-          && ( sample == rhs.sample );
-    }
-
-    bool operator!=( CoarseSampleLocationNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t pixelX;
-    uint32_t pixelY;
-    uint32_t sample;
+    eObject = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV,
+    eBuildScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV,
+    eUpdateScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV
   };
-  static_assert( sizeof( CoarseSampleLocationNV ) == sizeof( VkCoarseSampleLocationNV ), "struct and wrapper have different size!" );
 
-  struct DrawMeshTasksIndirectCommandNV
+  VULKAN_HPP_INLINE std::string to_string( AccelerationStructureMemoryRequirementsTypeNV value )
   {
-    DrawMeshTasksIndirectCommandNV( uint32_t taskCount_ = 0,
-                                    uint32_t firstTask_ = 0 )
-      : taskCount( taskCount_ )
-      , firstTask( firstTask_ )
-    {
-    }
-
-    DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
-    }
-
-    DrawMeshTasksIndirectCommandNV& operator=( VkDrawMeshTasksIndirectCommandNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
-      return *this;
-    }
-    DrawMeshTasksIndirectCommandNV& setTaskCount( uint32_t taskCount_ )
-    {
-      taskCount = taskCount_;
-      return *this;
-    }
-
-    DrawMeshTasksIndirectCommandNV& setFirstTask( uint32_t firstTask_ )
-    {
-      firstTask = firstTask_;
-      return *this;
-    }
-
-    operator VkDrawMeshTasksIndirectCommandNV const&() const
-    {
-      return *reinterpret_cast<const VkDrawMeshTasksIndirectCommandNV*>(this);
-    }
-
-    operator VkDrawMeshTasksIndirectCommandNV &()
-    {
-      return *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>(this);
-    }
-
-    bool operator==( DrawMeshTasksIndirectCommandNV const& rhs ) const
-    {
-      return ( taskCount == rhs.taskCount )
-          && ( firstTask == rhs.firstTask );
-    }
-
-    bool operator!=( DrawMeshTasksIndirectCommandNV const& rhs ) const
+    switch ( value )
     {
-      return !operator==( rhs );
+      case AccelerationStructureMemoryRequirementsTypeNV::eObject : return "Object";
+      case AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch : return "BuildScratch";
+      case AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch : return "UpdateScratch";
+      default: return "invalid";
     }
+  }
 
-    uint32_t taskCount;
-    uint32_t firstTask;
-  };
-  static_assert( sizeof( DrawMeshTasksIndirectCommandNV ) == sizeof( VkDrawMeshTasksIndirectCommandNV ), "struct and wrapper have different size!" );
-
-  enum class ImageLayout
-  {
-    eUndefined = VK_IMAGE_LAYOUT_UNDEFINED,
-    eGeneral = VK_IMAGE_LAYOUT_GENERAL,
-    eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-    eDepthStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-    eDepthStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
-    eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-    eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-    eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-    ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED,
-    eDepthReadOnlyStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
-    eDepthReadOnlyStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
-    eDepthAttachmentStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
-    eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
-    ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
-    eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR,
-    eShadingRateOptimalNV = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV,
-    eFragmentDensityMapOptimalEXT = VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT
-  };
-
-  struct DescriptorImageInfo
+  enum class AccelerationStructureTypeNV
   {
-    DescriptorImageInfo( Sampler sampler_ = Sampler(),
-                         ImageView imageView_ = ImageView(),
-                         ImageLayout imageLayout_ = ImageLayout::eUndefined )
-      : sampler( sampler_ )
-      , imageView( imageView_ )
-      , imageLayout( imageLayout_ )
-    {
-    }
-
-    DescriptorImageInfo( VkDescriptorImageInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
-    }
-
-    DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
-      return *this;
-    }
-    DescriptorImageInfo& setSampler( Sampler sampler_ )
-    {
-      sampler = sampler_;
-      return *this;
-    }
-
-    DescriptorImageInfo& setImageView( ImageView imageView_ )
-    {
-      imageView = imageView_;
-      return *this;
-    }
-
-    DescriptorImageInfo& setImageLayout( ImageLayout imageLayout_ )
-    {
-      imageLayout = imageLayout_;
-      return *this;
-    }
-
-    operator VkDescriptorImageInfo const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorImageInfo*>(this);
-    }
-
-    operator VkDescriptorImageInfo &()
-    {
-      return *reinterpret_cast<VkDescriptorImageInfo*>(this);
-    }
-
-    bool operator==( DescriptorImageInfo const& rhs ) const
-    {
-      return ( sampler == rhs.sampler )
-          && ( imageView == rhs.imageView )
-          && ( imageLayout == rhs.imageLayout );
-    }
-
-    bool operator!=( DescriptorImageInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Sampler sampler;
-    ImageView imageView;
-    ImageLayout imageLayout;
+    eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV,
+    eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV
   };
-  static_assert( sizeof( DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" );
 
-  struct AttachmentReference
+  VULKAN_HPP_INLINE std::string to_string( AccelerationStructureTypeNV value )
   {
-    AttachmentReference( uint32_t attachment_ = 0,
-                         ImageLayout layout_ = ImageLayout::eUndefined )
-      : attachment( attachment_ )
-      , layout( layout_ )
-    {
-    }
-
-    AttachmentReference( VkAttachmentReference const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentReference ) );
-    }
-
-    AttachmentReference& operator=( VkAttachmentReference const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentReference ) );
-      return *this;
-    }
-    AttachmentReference& setAttachment( uint32_t attachment_ )
-    {
-      attachment = attachment_;
-      return *this;
-    }
-
-    AttachmentReference& setLayout( ImageLayout layout_ )
-    {
-      layout = layout_;
-      return *this;
-    }
-
-    operator VkAttachmentReference const&() const
-    {
-      return *reinterpret_cast<const VkAttachmentReference*>(this);
-    }
-
-    operator VkAttachmentReference &()
+    switch ( value )
     {
-      return *reinterpret_cast<VkAttachmentReference*>(this);
+      case AccelerationStructureTypeNV::eTopLevel : return "TopLevel";
+      case AccelerationStructureTypeNV::eBottomLevel : return "BottomLevel";
+      default: return "invalid";
     }
-
-    bool operator==( AttachmentReference const& rhs ) const
-    {
-      return ( attachment == rhs.attachment )
-          && ( layout == rhs.layout );
-    }
-
-    bool operator!=( AttachmentReference const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t attachment;
-    ImageLayout layout;
-  };
-  static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" );
+  }
 
   enum class AttachmentLoadOp
   {
@@ -8045,439 +2501,33 @@ public:
     eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE
   };
 
+  VULKAN_HPP_INLINE std::string to_string( AttachmentLoadOp value )
+  {
+    switch ( value )
+    {
+      case AttachmentLoadOp::eLoad : return "Load";
+      case AttachmentLoadOp::eClear : return "Clear";
+      case AttachmentLoadOp::eDontCare : return "DontCare";
+      default: return "invalid";
+    }
+  }
+
   enum class AttachmentStoreOp
   {
     eStore = VK_ATTACHMENT_STORE_OP_STORE,
     eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE
   };
 
-  enum class ImageType
+  VULKAN_HPP_INLINE std::string to_string( AttachmentStoreOp value )
   {
-    e1D = VK_IMAGE_TYPE_1D,
-    e2D = VK_IMAGE_TYPE_2D,
-    e3D = VK_IMAGE_TYPE_3D
-  };
-
-  enum class ImageTiling
-  {
-    eOptimal = VK_IMAGE_TILING_OPTIMAL,
-    eLinear = VK_IMAGE_TILING_LINEAR,
-    eDrmFormatModifierEXT = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT
-  };
-
-  enum class ImageViewType
-  {
-    e1D = VK_IMAGE_VIEW_TYPE_1D,
-    e2D = VK_IMAGE_VIEW_TYPE_2D,
-    e3D = VK_IMAGE_VIEW_TYPE_3D,
-    eCube = VK_IMAGE_VIEW_TYPE_CUBE,
-    e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY,
-    e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY,
-    eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
-  };
-
-  enum class CommandBufferLevel
-  {
-    ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
-    eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY
-  };
-
-  enum class ComponentSwizzle
-  {
-    eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY,
-    eZero = VK_COMPONENT_SWIZZLE_ZERO,
-    eOne = VK_COMPONENT_SWIZZLE_ONE,
-    eR = VK_COMPONENT_SWIZZLE_R,
-    eG = VK_COMPONENT_SWIZZLE_G,
-    eB = VK_COMPONENT_SWIZZLE_B,
-    eA = VK_COMPONENT_SWIZZLE_A
-  };
-
-  struct ComponentMapping
-  {
-    ComponentMapping( ComponentSwizzle r_ = ComponentSwizzle::eIdentity,
-                      ComponentSwizzle g_ = ComponentSwizzle::eIdentity,
-                      ComponentSwizzle b_ = ComponentSwizzle::eIdentity,
-                      ComponentSwizzle a_ = ComponentSwizzle::eIdentity )
-      : r( r_ )
-      , g( g_ )
-      , b( b_ )
-      , a( a_ )
+    switch ( value )
     {
+      case AttachmentStoreOp::eStore : return "Store";
+      case AttachmentStoreOp::eDontCare : return "DontCare";
+      default: return "invalid";
     }
-
-    ComponentMapping( VkComponentMapping const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ComponentMapping ) );
-    }
-
-    ComponentMapping& operator=( VkComponentMapping const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ComponentMapping ) );
-      return *this;
-    }
-    ComponentMapping& setR( ComponentSwizzle r_ )
-    {
-      r = r_;
-      return *this;
-    }
-
-    ComponentMapping& setG( ComponentSwizzle g_ )
-    {
-      g = g_;
-      return *this;
-    }
-
-    ComponentMapping& setB( ComponentSwizzle b_ )
-    {
-      b = b_;
-      return *this;
-    }
-
-    ComponentMapping& setA( ComponentSwizzle a_ )
-    {
-      a = a_;
-      return *this;
-    }
-
-    operator VkComponentMapping const&() const
-    {
-      return *reinterpret_cast<const VkComponentMapping*>(this);
-    }
-
-    operator VkComponentMapping &()
-    {
-      return *reinterpret_cast<VkComponentMapping*>(this);
-    }
-
-    bool operator==( ComponentMapping const& rhs ) const
-    {
-      return ( r == rhs.r )
-          && ( g == rhs.g )
-          && ( b == rhs.b )
-          && ( a == rhs.a );
-    }
-
-    bool operator!=( ComponentMapping const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ComponentSwizzle r;
-    ComponentSwizzle g;
-    ComponentSwizzle b;
-    ComponentSwizzle a;
-  };
-  static_assert( sizeof( ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" );
-
-  enum class DescriptorType
-  {
-    eSampler = VK_DESCRIPTOR_TYPE_SAMPLER,
-    eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-    eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
-    eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-    eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
-    eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
-    eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-    eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-    eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
-    eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
-    eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
-    eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT,
-    eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV
-  };
-
-  struct DescriptorPoolSize
-  {
-    DescriptorPoolSize( DescriptorType type_ = DescriptorType::eSampler,
-                        uint32_t descriptorCount_ = 0 )
-      : type( type_ )
-      , descriptorCount( descriptorCount_ )
-    {
-    }
-
-    DescriptorPoolSize( VkDescriptorPoolSize const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
-    }
-
-    DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
-      return *this;
-    }
-    DescriptorPoolSize& setType( DescriptorType type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    DescriptorPoolSize& setDescriptorCount( uint32_t descriptorCount_ )
-    {
-      descriptorCount = descriptorCount_;
-      return *this;
-    }
-
-    operator VkDescriptorPoolSize const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorPoolSize*>(this);
-    }
-
-    operator VkDescriptorPoolSize &()
-    {
-      return *reinterpret_cast<VkDescriptorPoolSize*>(this);
-    }
-
-    bool operator==( DescriptorPoolSize const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( descriptorCount == rhs.descriptorCount );
-    }
-
-    bool operator!=( DescriptorPoolSize const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DescriptorType type;
-    uint32_t descriptorCount;
-  };
-  static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" );
-
-  struct DescriptorUpdateTemplateEntry
-  {
-    DescriptorUpdateTemplateEntry( uint32_t dstBinding_ = 0,
-                                   uint32_t dstArrayElement_ = 0,
-                                   uint32_t descriptorCount_ = 0,
-                                   DescriptorType descriptorType_ = DescriptorType::eSampler,
-                                   size_t offset_ = 0,
-                                   size_t stride_ = 0 )
-      : dstBinding( dstBinding_ )
-      , dstArrayElement( dstArrayElement_ )
-      , descriptorCount( descriptorCount_ )
-      , descriptorType( descriptorType_ )
-      , offset( offset_ )
-      , stride( stride_ )
-    {
-    }
-
-    DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) );
-    }
-
-    DescriptorUpdateTemplateEntry& operator=( VkDescriptorUpdateTemplateEntry const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) );
-      return *this;
-    }
-    DescriptorUpdateTemplateEntry& setDstBinding( uint32_t dstBinding_ )
-    {
-      dstBinding = dstBinding_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntry& setDstArrayElement( uint32_t dstArrayElement_ )
-    {
-      dstArrayElement = dstArrayElement_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntry& setDescriptorCount( uint32_t descriptorCount_ )
-    {
-      descriptorCount = descriptorCount_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntry& setDescriptorType( DescriptorType descriptorType_ )
-    {
-      descriptorType = descriptorType_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntry& setOffset( size_t offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntry& setStride( size_t stride_ )
-    {
-      stride = stride_;
-      return *this;
-    }
-
-    operator VkDescriptorUpdateTemplateEntry const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorUpdateTemplateEntry*>(this);
-    }
-
-    operator VkDescriptorUpdateTemplateEntry &()
-    {
-      return *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>(this);
-    }
-
-    bool operator==( DescriptorUpdateTemplateEntry const& rhs ) const
-    {
-      return ( dstBinding == rhs.dstBinding )
-          && ( dstArrayElement == rhs.dstArrayElement )
-          && ( descriptorCount == rhs.descriptorCount )
-          && ( descriptorType == rhs.descriptorType )
-          && ( offset == rhs.offset )
-          && ( stride == rhs.stride );
-    }
-
-    bool operator!=( DescriptorUpdateTemplateEntry const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t dstBinding;
-    uint32_t dstArrayElement;
-    uint32_t descriptorCount;
-    DescriptorType descriptorType;
-    size_t offset;
-    size_t stride;
-  };
-  static_assert( sizeof( DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), "struct and wrapper have different size!" );
-
-  using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
-
-  enum class QueryType
-  {
-    eOcclusion = VK_QUERY_TYPE_OCCLUSION,
-    ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
-    eTimestamp = VK_QUERY_TYPE_TIMESTAMP,
-    eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT,
-    eAccelerationStructureCompactedSizeNV = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV
-  };
-
-  enum class BorderColor
-  {
-    eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
-    eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,
-    eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
-    eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
-    eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
-    eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE
-  };
-
-  enum class PipelineBindPoint
-  {
-    eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS,
-    eCompute = VK_PIPELINE_BIND_POINT_COMPUTE,
-    eRayTracingNV = VK_PIPELINE_BIND_POINT_RAY_TRACING_NV
-  };
-
-  enum class PipelineCacheHeaderVersion
-  {
-    eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE
-  };
-
-  enum class PrimitiveTopology
-  {
-    ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
-    eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST,
-    eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
-    eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
-    eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
-    eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,
-    eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY,
-    eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY,
-    eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY,
-    eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY,
-    ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
-  };
-
-  enum class SharingMode
-  {
-    eExclusive = VK_SHARING_MODE_EXCLUSIVE,
-    eConcurrent = VK_SHARING_MODE_CONCURRENT
-  };
-
-  enum class IndexType
-  {
-    eUint16 = VK_INDEX_TYPE_UINT16,
-    eUint32 = VK_INDEX_TYPE_UINT32,
-    eNoneNV = VK_INDEX_TYPE_NONE_NV
-  };
-
-  enum class Filter
-  {
-    eNearest = VK_FILTER_NEAREST,
-    eLinear = VK_FILTER_LINEAR,
-    eCubicIMG = VK_FILTER_CUBIC_IMG
-  };
-
-  enum class SamplerMipmapMode
-  {
-    eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST,
-    eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR
-  };
-
-  enum class SamplerAddressMode
-  {
-    eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT,
-    eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
-    eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
-    eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
-    eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE
-  };
-
-  enum class CompareOp
-  {
-    eNever = VK_COMPARE_OP_NEVER,
-    eLess = VK_COMPARE_OP_LESS,
-    eEqual = VK_COMPARE_OP_EQUAL,
-    eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL,
-    eGreater = VK_COMPARE_OP_GREATER,
-    eNotEqual = VK_COMPARE_OP_NOT_EQUAL,
-    eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL,
-    eAlways = VK_COMPARE_OP_ALWAYS
-  };
-
-  enum class PolygonMode
-  {
-    eFill = VK_POLYGON_MODE_FILL,
-    eLine = VK_POLYGON_MODE_LINE,
-    ePoint = VK_POLYGON_MODE_POINT,
-    eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV
-  };
-
-  enum class CullModeFlagBits
-  {
-    eNone = VK_CULL_MODE_NONE,
-    eFront = VK_CULL_MODE_FRONT_BIT,
-    eBack = VK_CULL_MODE_BACK_BIT,
-    eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK
-  };
-
-  using CullModeFlags = Flags<CullModeFlagBits, VkCullModeFlags>;
-
-  VULKAN_HPP_INLINE CullModeFlags operator|( CullModeFlagBits bit0, CullModeFlagBits bit1 )
-  {
-    return CullModeFlags( bit0 ) | bit1;
   }
 
-  VULKAN_HPP_INLINE CullModeFlags operator~( CullModeFlagBits bits )
-  {
-    return ~( CullModeFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<CullModeFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(CullModeFlagBits::eNone) | VkFlags(CullModeFlagBits::eFront) | VkFlags(CullModeFlagBits::eBack) | VkFlags(CullModeFlagBits::eFrontAndBack)
-    };
-  };
-
-  enum class FrontFace
-  {
-    eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE,
-    eClockwise = VK_FRONT_FACE_CLOCKWISE
-  };
-
   enum class BlendFactor
   {
     eZero = VK_BLEND_FACTOR_ZERO,
@@ -8501,6 +2551,33 @@ public:
     eOneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
   };
 
+  VULKAN_HPP_INLINE std::string to_string( BlendFactor value )
+  {
+    switch ( value )
+    {
+      case BlendFactor::eZero : return "Zero";
+      case BlendFactor::eOne : return "One";
+      case BlendFactor::eSrcColor : return "SrcColor";
+      case BlendFactor::eOneMinusSrcColor : return "OneMinusSrcColor";
+      case BlendFactor::eDstColor : return "DstColor";
+      case BlendFactor::eOneMinusDstColor : return "OneMinusDstColor";
+      case BlendFactor::eSrcAlpha : return "SrcAlpha";
+      case BlendFactor::eOneMinusSrcAlpha : return "OneMinusSrcAlpha";
+      case BlendFactor::eDstAlpha : return "DstAlpha";
+      case BlendFactor::eOneMinusDstAlpha : return "OneMinusDstAlpha";
+      case BlendFactor::eConstantColor : return "ConstantColor";
+      case BlendFactor::eOneMinusConstantColor : return "OneMinusConstantColor";
+      case BlendFactor::eConstantAlpha : return "ConstantAlpha";
+      case BlendFactor::eOneMinusConstantAlpha : return "OneMinusConstantAlpha";
+      case BlendFactor::eSrcAlphaSaturate : return "SrcAlphaSaturate";
+      case BlendFactor::eSrc1Color : return "Src1Color";
+      case BlendFactor::eOneMinusSrc1Color : return "OneMinusSrc1Color";
+      case BlendFactor::eSrc1Alpha : return "Src1Alpha";
+      case BlendFactor::eOneMinusSrc1Alpha : return "OneMinusSrc1Alpha";
+      default: return "invalid";
+    }
+  }
+
   enum class BlendOp
   {
     eAdd = VK_BLEND_OP_ADD,
@@ -8556,240 +2633,610 @@ public:
     eBlueEXT = VK_BLEND_OP_BLUE_EXT
   };
 
-  enum class StencilOp
+  VULKAN_HPP_INLINE std::string to_string( BlendOp value )
   {
-    eKeep = VK_STENCIL_OP_KEEP,
-    eZero = VK_STENCIL_OP_ZERO,
-    eReplace = VK_STENCIL_OP_REPLACE,
-    eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP,
-    eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP,
-    eInvert = VK_STENCIL_OP_INVERT,
-    eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP,
-    eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP
+    switch ( value )
+    {
+      case BlendOp::eAdd : return "Add";
+      case BlendOp::eSubtract : return "Subtract";
+      case BlendOp::eReverseSubtract : return "ReverseSubtract";
+      case BlendOp::eMin : return "Min";
+      case BlendOp::eMax : return "Max";
+      case BlendOp::eZeroEXT : return "ZeroEXT";
+      case BlendOp::eSrcEXT : return "SrcEXT";
+      case BlendOp::eDstEXT : return "DstEXT";
+      case BlendOp::eSrcOverEXT : return "SrcOverEXT";
+      case BlendOp::eDstOverEXT : return "DstOverEXT";
+      case BlendOp::eSrcInEXT : return "SrcInEXT";
+      case BlendOp::eDstInEXT : return "DstInEXT";
+      case BlendOp::eSrcOutEXT : return "SrcOutEXT";
+      case BlendOp::eDstOutEXT : return "DstOutEXT";
+      case BlendOp::eSrcAtopEXT : return "SrcAtopEXT";
+      case BlendOp::eDstAtopEXT : return "DstAtopEXT";
+      case BlendOp::eXorEXT : return "XorEXT";
+      case BlendOp::eMultiplyEXT : return "MultiplyEXT";
+      case BlendOp::eScreenEXT : return "ScreenEXT";
+      case BlendOp::eOverlayEXT : return "OverlayEXT";
+      case BlendOp::eDarkenEXT : return "DarkenEXT";
+      case BlendOp::eLightenEXT : return "LightenEXT";
+      case BlendOp::eColordodgeEXT : return "ColordodgeEXT";
+      case BlendOp::eColorburnEXT : return "ColorburnEXT";
+      case BlendOp::eHardlightEXT : return "HardlightEXT";
+      case BlendOp::eSoftlightEXT : return "SoftlightEXT";
+      case BlendOp::eDifferenceEXT : return "DifferenceEXT";
+      case BlendOp::eExclusionEXT : return "ExclusionEXT";
+      case BlendOp::eInvertEXT : return "InvertEXT";
+      case BlendOp::eInvertRgbEXT : return "InvertRgbEXT";
+      case BlendOp::eLineardodgeEXT : return "LineardodgeEXT";
+      case BlendOp::eLinearburnEXT : return "LinearburnEXT";
+      case BlendOp::eVividlightEXT : return "VividlightEXT";
+      case BlendOp::eLinearlightEXT : return "LinearlightEXT";
+      case BlendOp::ePinlightEXT : return "PinlightEXT";
+      case BlendOp::eHardmixEXT : return "HardmixEXT";
+      case BlendOp::eHslHueEXT : return "HslHueEXT";
+      case BlendOp::eHslSaturationEXT : return "HslSaturationEXT";
+      case BlendOp::eHslColorEXT : return "HslColorEXT";
+      case BlendOp::eHslLuminosityEXT : return "HslLuminosityEXT";
+      case BlendOp::ePlusEXT : return "PlusEXT";
+      case BlendOp::ePlusClampedEXT : return "PlusClampedEXT";
+      case BlendOp::ePlusClampedAlphaEXT : return "PlusClampedAlphaEXT";
+      case BlendOp::ePlusDarkerEXT : return "PlusDarkerEXT";
+      case BlendOp::eMinusEXT : return "MinusEXT";
+      case BlendOp::eMinusClampedEXT : return "MinusClampedEXT";
+      case BlendOp::eContrastEXT : return "ContrastEXT";
+      case BlendOp::eInvertOvgEXT : return "InvertOvgEXT";
+      case BlendOp::eRedEXT : return "RedEXT";
+      case BlendOp::eGreenEXT : return "GreenEXT";
+      case BlendOp::eBlueEXT : return "BlueEXT";
+      default: return "invalid";
+    }
+  }
+
+  enum class BlendOverlapEXT
+  {
+    eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
+    eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT,
+    eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT
   };
 
-  struct StencilOpState
+  VULKAN_HPP_INLINE std::string to_string( BlendOverlapEXT value )
   {
-    StencilOpState( StencilOp failOp_ = StencilOp::eKeep,
-                    StencilOp passOp_ = StencilOp::eKeep,
-                    StencilOp depthFailOp_ = StencilOp::eKeep,
-                    CompareOp compareOp_ = CompareOp::eNever,
-                    uint32_t compareMask_ = 0,
-                    uint32_t writeMask_ = 0,
-                    uint32_t reference_ = 0 )
-      : failOp( failOp_ )
-      , passOp( passOp_ )
-      , depthFailOp( depthFailOp_ )
-      , compareOp( compareOp_ )
-      , compareMask( compareMask_ )
-      , writeMask( writeMask_ )
-      , reference( reference_ )
+    switch ( value )
     {
+      case BlendOverlapEXT::eUncorrelated : return "Uncorrelated";
+      case BlendOverlapEXT::eDisjoint : return "Disjoint";
+      case BlendOverlapEXT::eConjoint : return "Conjoint";
+      default: return "invalid";
     }
+  }
 
-    StencilOpState( VkStencilOpState const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( StencilOpState ) );
-    }
-
-    StencilOpState& operator=( VkStencilOpState const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( StencilOpState ) );
-      return *this;
-    }
-    StencilOpState& setFailOp( StencilOp failOp_ )
-    {
-      failOp = failOp_;
-      return *this;
-    }
-
-    StencilOpState& setPassOp( StencilOp passOp_ )
-    {
-      passOp = passOp_;
-      return *this;
-    }
-
-    StencilOpState& setDepthFailOp( StencilOp depthFailOp_ )
-    {
-      depthFailOp = depthFailOp_;
-      return *this;
-    }
-
-    StencilOpState& setCompareOp( CompareOp compareOp_ )
-    {
-      compareOp = compareOp_;
-      return *this;
-    }
-
-    StencilOpState& setCompareMask( uint32_t compareMask_ )
-    {
-      compareMask = compareMask_;
-      return *this;
-    }
-
-    StencilOpState& setWriteMask( uint32_t writeMask_ )
-    {
-      writeMask = writeMask_;
-      return *this;
-    }
-
-    StencilOpState& setReference( uint32_t reference_ )
-    {
-      reference = reference_;
-      return *this;
-    }
-
-    operator VkStencilOpState const&() const
-    {
-      return *reinterpret_cast<const VkStencilOpState*>(this);
-    }
-
-    operator VkStencilOpState &()
-    {
-      return *reinterpret_cast<VkStencilOpState*>(this);
-    }
-
-    bool operator==( StencilOpState const& rhs ) const
-    {
-      return ( failOp == rhs.failOp )
-          && ( passOp == rhs.passOp )
-          && ( depthFailOp == rhs.depthFailOp )
-          && ( compareOp == rhs.compareOp )
-          && ( compareMask == rhs.compareMask )
-          && ( writeMask == rhs.writeMask )
-          && ( reference == rhs.reference );
-    }
-
-    bool operator!=( StencilOpState const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    StencilOp failOp;
-    StencilOp passOp;
-    StencilOp depthFailOp;
-    CompareOp compareOp;
-    uint32_t compareMask;
-    uint32_t writeMask;
-    uint32_t reference;
-  };
-  static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" );
-
-  enum class LogicOp
+  enum class BorderColor
   {
-    eClear = VK_LOGIC_OP_CLEAR,
-    eAnd = VK_LOGIC_OP_AND,
-    eAndReverse = VK_LOGIC_OP_AND_REVERSE,
-    eCopy = VK_LOGIC_OP_COPY,
-    eAndInverted = VK_LOGIC_OP_AND_INVERTED,
-    eNoOp = VK_LOGIC_OP_NO_OP,
-    eXor = VK_LOGIC_OP_XOR,
-    eOr = VK_LOGIC_OP_OR,
-    eNor = VK_LOGIC_OP_NOR,
-    eEquivalent = VK_LOGIC_OP_EQUIVALENT,
-    eInvert = VK_LOGIC_OP_INVERT,
-    eOrReverse = VK_LOGIC_OP_OR_REVERSE,
-    eCopyInverted = VK_LOGIC_OP_COPY_INVERTED,
-    eOrInverted = VK_LOGIC_OP_OR_INVERTED,
-    eNand = VK_LOGIC_OP_NAND,
-    eSet = VK_LOGIC_OP_SET
+    eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
+    eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,
+    eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
+    eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
+    eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
+    eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE
   };
 
-  enum class InternalAllocationType
+  VULKAN_HPP_INLINE std::string to_string( BorderColor value )
   {
-    eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE
+    switch ( value )
+    {
+      case BorderColor::eFloatTransparentBlack : return "FloatTransparentBlack";
+      case BorderColor::eIntTransparentBlack : return "IntTransparentBlack";
+      case BorderColor::eFloatOpaqueBlack : return "FloatOpaqueBlack";
+      case BorderColor::eIntOpaqueBlack : return "IntOpaqueBlack";
+      case BorderColor::eFloatOpaqueWhite : return "FloatOpaqueWhite";
+      case BorderColor::eIntOpaqueWhite : return "IntOpaqueWhite";
+      default: return "invalid";
+    }
+  }
+
+  enum class ChromaLocation
+  {
+    eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN,
+    eMidpoint = VK_CHROMA_LOCATION_MIDPOINT,
+    eCositedEvenKHR = VK_CHROMA_LOCATION_COSITED_EVEN_KHR,
+    eMidpointKHR = VK_CHROMA_LOCATION_MIDPOINT_KHR
   };
 
-  enum class SystemAllocationScope
+  VULKAN_HPP_INLINE std::string to_string( ChromaLocation value )
   {
-    eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
-    eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT,
-    eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE,
-    eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE,
-    eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
+    switch ( value )
+    {
+      case ChromaLocation::eCositedEven : return "CositedEven";
+      case ChromaLocation::eMidpoint : return "Midpoint";
+      default: return "invalid";
+    }
+  }
+
+  enum class CoarseSampleOrderTypeNV
+  {
+    eDefault = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV,
+    eCustom = VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV,
+    ePixelMajor = VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV,
+    eSampleMajor = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV
   };
 
-  enum class PhysicalDeviceType
+  VULKAN_HPP_INLINE std::string to_string( CoarseSampleOrderTypeNV value )
   {
-    eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER,
-    eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
-    eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
-    eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU,
-    eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU
+    switch ( value )
+    {
+      case CoarseSampleOrderTypeNV::eDefault : return "Default";
+      case CoarseSampleOrderTypeNV::eCustom : return "Custom";
+      case CoarseSampleOrderTypeNV::ePixelMajor : return "PixelMajor";
+      case CoarseSampleOrderTypeNV::eSampleMajor : return "SampleMajor";
+      default: return "invalid";
+    }
+  }
+
+  enum class ColorSpaceKHR
+  {
+    eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
+    eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT,
+    eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT,
+    eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT,
+    eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT,
+    eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT,
+    eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT,
+    eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT,
+    eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT,
+    eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT,
+    eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT,
+    eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT,
+    eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT,
+    ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT,
+    eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT,
+    eVkColorspaceSrgbNonlinear = VK_COLORSPACE_SRGB_NONLINEAR_KHR
   };
 
-  enum class VertexInputRate
+  VULKAN_HPP_INLINE std::string to_string( ColorSpaceKHR value )
   {
-    eVertex = VK_VERTEX_INPUT_RATE_VERTEX,
-    eInstance = VK_VERTEX_INPUT_RATE_INSTANCE
+    switch ( value )
+    {
+      case ColorSpaceKHR::eSrgbNonlinear : return "SrgbNonlinear";
+      case ColorSpaceKHR::eDisplayP3NonlinearEXT : return "DisplayP3NonlinearEXT";
+      case ColorSpaceKHR::eExtendedSrgbLinearEXT : return "ExtendedSrgbLinearEXT";
+      case ColorSpaceKHR::eDciP3LinearEXT : return "DciP3LinearEXT";
+      case ColorSpaceKHR::eDciP3NonlinearEXT : return "DciP3NonlinearEXT";
+      case ColorSpaceKHR::eBt709LinearEXT : return "Bt709LinearEXT";
+      case ColorSpaceKHR::eBt709NonlinearEXT : return "Bt709NonlinearEXT";
+      case ColorSpaceKHR::eBt2020LinearEXT : return "Bt2020LinearEXT";
+      case ColorSpaceKHR::eHdr10St2084EXT : return "Hdr10St2084EXT";
+      case ColorSpaceKHR::eDolbyvisionEXT : return "DolbyvisionEXT";
+      case ColorSpaceKHR::eHdr10HlgEXT : return "Hdr10HlgEXT";
+      case ColorSpaceKHR::eAdobergbLinearEXT : return "AdobergbLinearEXT";
+      case ColorSpaceKHR::eAdobergbNonlinearEXT : return "AdobergbNonlinearEXT";
+      case ColorSpaceKHR::ePassThroughEXT : return "PassThroughEXT";
+      case ColorSpaceKHR::eExtendedSrgbNonlinearEXT : return "ExtendedSrgbNonlinearEXT";
+      default: return "invalid";
+    }
+  }
+
+  enum class CommandBufferLevel
+  {
+    ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+    eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY
   };
 
-  struct VertexInputBindingDescription
+  VULKAN_HPP_INLINE std::string to_string( CommandBufferLevel value )
   {
-    VertexInputBindingDescription( uint32_t binding_ = 0,
-                                   uint32_t stride_ = 0,
-                                   VertexInputRate inputRate_ = VertexInputRate::eVertex )
-      : binding( binding_ )
-      , stride( stride_ )
-      , inputRate( inputRate_ )
+    switch ( value )
     {
+      case CommandBufferLevel::ePrimary : return "Primary";
+      case CommandBufferLevel::eSecondary : return "Secondary";
+      default: return "invalid";
     }
+  }
 
-    VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
-    }
-
-    VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
-      return *this;
-    }
-    VertexInputBindingDescription& setBinding( uint32_t binding_ )
-    {
-      binding = binding_;
-      return *this;
-    }
-
-    VertexInputBindingDescription& setStride( uint32_t stride_ )
-    {
-      stride = stride_;
-      return *this;
-    }
-
-    VertexInputBindingDescription& setInputRate( VertexInputRate inputRate_ )
-    {
-      inputRate = inputRate_;
-      return *this;
-    }
-
-    operator VkVertexInputBindingDescription const&() const
-    {
-      return *reinterpret_cast<const VkVertexInputBindingDescription*>(this);
-    }
-
-    operator VkVertexInputBindingDescription &()
-    {
-      return *reinterpret_cast<VkVertexInputBindingDescription*>(this);
-    }
-
-    bool operator==( VertexInputBindingDescription const& rhs ) const
-    {
-      return ( binding == rhs.binding )
-          && ( stride == rhs.stride )
-          && ( inputRate == rhs.inputRate );
-    }
-
-    bool operator!=( VertexInputBindingDescription const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t binding;
-    uint32_t stride;
-    VertexInputRate inputRate;
+  enum class CompareOp
+  {
+    eNever = VK_COMPARE_OP_NEVER,
+    eLess = VK_COMPARE_OP_LESS,
+    eEqual = VK_COMPARE_OP_EQUAL,
+    eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL,
+    eGreater = VK_COMPARE_OP_GREATER,
+    eNotEqual = VK_COMPARE_OP_NOT_EQUAL,
+    eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL,
+    eAlways = VK_COMPARE_OP_ALWAYS
   };
-  static_assert( sizeof( VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), "struct and wrapper have different size!" );
+
+  VULKAN_HPP_INLINE std::string to_string( CompareOp value )
+  {
+    switch ( value )
+    {
+      case CompareOp::eNever : return "Never";
+      case CompareOp::eLess : return "Less";
+      case CompareOp::eEqual : return "Equal";
+      case CompareOp::eLessOrEqual : return "LessOrEqual";
+      case CompareOp::eGreater : return "Greater";
+      case CompareOp::eNotEqual : return "NotEqual";
+      case CompareOp::eGreaterOrEqual : return "GreaterOrEqual";
+      case CompareOp::eAlways : return "Always";
+      default: return "invalid";
+    }
+  }
+
+  enum class ComponentSwizzle
+  {
+    eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY,
+    eZero = VK_COMPONENT_SWIZZLE_ZERO,
+    eOne = VK_COMPONENT_SWIZZLE_ONE,
+    eR = VK_COMPONENT_SWIZZLE_R,
+    eG = VK_COMPONENT_SWIZZLE_G,
+    eB = VK_COMPONENT_SWIZZLE_B,
+    eA = VK_COMPONENT_SWIZZLE_A
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ComponentSwizzle value )
+  {
+    switch ( value )
+    {
+      case ComponentSwizzle::eIdentity : return "Identity";
+      case ComponentSwizzle::eZero : return "Zero";
+      case ComponentSwizzle::eOne : return "One";
+      case ComponentSwizzle::eR : return "R";
+      case ComponentSwizzle::eG : return "G";
+      case ComponentSwizzle::eB : return "B";
+      case ComponentSwizzle::eA : return "A";
+      default: return "invalid";
+    }
+  }
+
+  enum class ConservativeRasterizationModeEXT
+  {
+    eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT,
+    eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT,
+    eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ConservativeRasterizationModeEXT value )
+  {
+    switch ( value )
+    {
+      case ConservativeRasterizationModeEXT::eDisabled : return "Disabled";
+      case ConservativeRasterizationModeEXT::eOverestimate : return "Overestimate";
+      case ConservativeRasterizationModeEXT::eUnderestimate : return "Underestimate";
+      default: return "invalid";
+    }
+  }
+
+  enum class CopyAccelerationStructureModeNV
+  {
+    eClone = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV,
+    eCompact = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CopyAccelerationStructureModeNV value )
+  {
+    switch ( value )
+    {
+      case CopyAccelerationStructureModeNV::eClone : return "Clone";
+      case CopyAccelerationStructureModeNV::eCompact : return "Compact";
+      default: return "invalid";
+    }
+  }
+
+  enum class CoverageModulationModeNV
+  {
+    eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV,
+    eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV,
+    eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV,
+    eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CoverageModulationModeNV value )
+  {
+    switch ( value )
+    {
+      case CoverageModulationModeNV::eNone : return "None";
+      case CoverageModulationModeNV::eRgb : return "Rgb";
+      case CoverageModulationModeNV::eAlpha : return "Alpha";
+      case CoverageModulationModeNV::eRgba : return "Rgba";
+      default: return "invalid";
+    }
+  }
+
+  enum class DebugReportObjectTypeEXT
+  {
+    eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+    eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
+    ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
+    eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
+    eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
+    eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
+    eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+    eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
+    eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
+    eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
+    eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+    eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
+    eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT,
+    eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT,
+    eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
+    eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT,
+    ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT,
+    ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT,
+    eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+    ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
+    eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT,
+    eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT,
+    eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
+    eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
+    eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT,
+    eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT,
+    eSurfaceKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT,
+    eSwapchainKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
+    eDebugReportCallbackEXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
+    eDisplayKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT,
+    eDisplayModeKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT,
+    eObjectTableNVX = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT,
+    eIndirectCommandsLayoutNVX = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT,
+    eValidationCacheEXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
+    eSamplerYcbcrConversion = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
+    eDescriptorUpdateTemplate = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
+    eAccelerationStructureNV = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
+    eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT,
+    eValidationCache = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT,
+    eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT,
+    eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DebugReportObjectTypeEXT value )
+  {
+    switch ( value )
+    {
+      case DebugReportObjectTypeEXT::eUnknown : return "Unknown";
+      case DebugReportObjectTypeEXT::eInstance : return "Instance";
+      case DebugReportObjectTypeEXT::ePhysicalDevice : return "PhysicalDevice";
+      case DebugReportObjectTypeEXT::eDevice : return "Device";
+      case DebugReportObjectTypeEXT::eQueue : return "Queue";
+      case DebugReportObjectTypeEXT::eSemaphore : return "Semaphore";
+      case DebugReportObjectTypeEXT::eCommandBuffer : return "CommandBuffer";
+      case DebugReportObjectTypeEXT::eFence : return "Fence";
+      case DebugReportObjectTypeEXT::eDeviceMemory : return "DeviceMemory";
+      case DebugReportObjectTypeEXT::eBuffer : return "Buffer";
+      case DebugReportObjectTypeEXT::eImage : return "Image";
+      case DebugReportObjectTypeEXT::eEvent : return "Event";
+      case DebugReportObjectTypeEXT::eQueryPool : return "QueryPool";
+      case DebugReportObjectTypeEXT::eBufferView : return "BufferView";
+      case DebugReportObjectTypeEXT::eImageView : return "ImageView";
+      case DebugReportObjectTypeEXT::eShaderModule : return "ShaderModule";
+      case DebugReportObjectTypeEXT::ePipelineCache : return "PipelineCache";
+      case DebugReportObjectTypeEXT::ePipelineLayout : return "PipelineLayout";
+      case DebugReportObjectTypeEXT::eRenderPass : return "RenderPass";
+      case DebugReportObjectTypeEXT::ePipeline : return "Pipeline";
+      case DebugReportObjectTypeEXT::eDescriptorSetLayout : return "DescriptorSetLayout";
+      case DebugReportObjectTypeEXT::eSampler : return "Sampler";
+      case DebugReportObjectTypeEXT::eDescriptorPool : return "DescriptorPool";
+      case DebugReportObjectTypeEXT::eDescriptorSet : return "DescriptorSet";
+      case DebugReportObjectTypeEXT::eFramebuffer : return "Framebuffer";
+      case DebugReportObjectTypeEXT::eCommandPool : return "CommandPool";
+      case DebugReportObjectTypeEXT::eSurfaceKHR : return "SurfaceKHR";
+      case DebugReportObjectTypeEXT::eSwapchainKHR : return "SwapchainKHR";
+      case DebugReportObjectTypeEXT::eDebugReportCallbackEXT : return "DebugReportCallbackEXT";
+      case DebugReportObjectTypeEXT::eDisplayKHR : return "DisplayKHR";
+      case DebugReportObjectTypeEXT::eDisplayModeKHR : return "DisplayModeKHR";
+      case DebugReportObjectTypeEXT::eObjectTableNVX : return "ObjectTableNVX";
+      case DebugReportObjectTypeEXT::eIndirectCommandsLayoutNVX : return "IndirectCommandsLayoutNVX";
+      case DebugReportObjectTypeEXT::eValidationCacheEXT : return "ValidationCacheEXT";
+      case DebugReportObjectTypeEXT::eSamplerYcbcrConversion : return "SamplerYcbcrConversion";
+      case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate : return "DescriptorUpdateTemplate";
+      case DebugReportObjectTypeEXT::eAccelerationStructureNV : return "AccelerationStructureNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class DescriptorType
+  {
+    eSampler = VK_DESCRIPTOR_TYPE_SAMPLER,
+    eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+    eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
+    eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
+    eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
+    eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
+    eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+    eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+    eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
+    eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
+    eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
+    eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT,
+    eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorType value )
+  {
+    switch ( value )
+    {
+      case DescriptorType::eSampler : return "Sampler";
+      case DescriptorType::eCombinedImageSampler : return "CombinedImageSampler";
+      case DescriptorType::eSampledImage : return "SampledImage";
+      case DescriptorType::eStorageImage : return "StorageImage";
+      case DescriptorType::eUniformTexelBuffer : return "UniformTexelBuffer";
+      case DescriptorType::eStorageTexelBuffer : return "StorageTexelBuffer";
+      case DescriptorType::eUniformBuffer : return "UniformBuffer";
+      case DescriptorType::eStorageBuffer : return "StorageBuffer";
+      case DescriptorType::eUniformBufferDynamic : return "UniformBufferDynamic";
+      case DescriptorType::eStorageBufferDynamic : return "StorageBufferDynamic";
+      case DescriptorType::eInputAttachment : return "InputAttachment";
+      case DescriptorType::eInlineUniformBlockEXT : return "InlineUniformBlockEXT";
+      case DescriptorType::eAccelerationStructureNV : return "AccelerationStructureNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class DescriptorUpdateTemplateType
+  {
+    eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
+    ePushDescriptorsKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR,
+    eDescriptorSetKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateType value )
+  {
+    switch ( value )
+    {
+      case DescriptorUpdateTemplateType::eDescriptorSet : return "DescriptorSet";
+      case DescriptorUpdateTemplateType::ePushDescriptorsKHR : return "PushDescriptorsKHR";
+      default: return "invalid";
+    }
+  }
+
+  enum class DeviceEventTypeEXT
+  {
+    eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DeviceEventTypeEXT value )
+  {
+    switch ( value )
+    {
+      case DeviceEventTypeEXT::eDisplayHotplug : return "DisplayHotplug";
+      default: return "invalid";
+    }
+  }
+
+  enum class DiscardRectangleModeEXT
+  {
+    eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
+    eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DiscardRectangleModeEXT value )
+  {
+    switch ( value )
+    {
+      case DiscardRectangleModeEXT::eInclusive : return "Inclusive";
+      case DiscardRectangleModeEXT::eExclusive : return "Exclusive";
+      default: return "invalid";
+    }
+  }
+
+  enum class DisplayEventTypeEXT
+  {
+    eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DisplayEventTypeEXT value )
+  {
+    switch ( value )
+    {
+      case DisplayEventTypeEXT::eFirstPixelOut : return "FirstPixelOut";
+      default: return "invalid";
+    }
+  }
+
+  enum class DisplayPowerStateEXT
+  {
+    eOff = VK_DISPLAY_POWER_STATE_OFF_EXT,
+    eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT,
+    eOn = VK_DISPLAY_POWER_STATE_ON_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DisplayPowerStateEXT value )
+  {
+    switch ( value )
+    {
+      case DisplayPowerStateEXT::eOff : return "Off";
+      case DisplayPowerStateEXT::eSuspend : return "Suspend";
+      case DisplayPowerStateEXT::eOn : return "On";
+      default: return "invalid";
+    }
+  }
+
+  enum class DriverIdKHR
+  {
+    eAmdProprietary = VK_DRIVER_ID_AMD_PROPRIETARY_KHR,
+    eAmdOpenSource = VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR,
+    eMesaRadv = VK_DRIVER_ID_MESA_RADV_KHR,
+    eNvidiaProprietary = VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR,
+    eIntelProprietaryWindows = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR,
+    eIntelOpenSourceMESA = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR,
+    eImaginationProprietary = VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR,
+    eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR,
+    eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY_KHR,
+    eGooglePastel = VK_DRIVER_ID_GOOGLE_PASTEL_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DriverIdKHR value )
+  {
+    switch ( value )
+    {
+      case DriverIdKHR::eAmdProprietary : return "AmdProprietary";
+      case DriverIdKHR::eAmdOpenSource : return "AmdOpenSource";
+      case DriverIdKHR::eMesaRadv : return "MesaRadv";
+      case DriverIdKHR::eNvidiaProprietary : return "NvidiaProprietary";
+      case DriverIdKHR::eIntelProprietaryWindows : return "IntelProprietaryWindows";
+      case DriverIdKHR::eIntelOpenSourceMESA : return "IntelOpenSourceMESA";
+      case DriverIdKHR::eImaginationProprietary : return "ImaginationProprietary";
+      case DriverIdKHR::eQualcommProprietary : return "QualcommProprietary";
+      case DriverIdKHR::eArmProprietary : return "ArmProprietary";
+      case DriverIdKHR::eGooglePastel : return "GooglePastel";
+      default: return "invalid";
+    }
+  }
+
+  enum class DynamicState
+  {
+    eViewport = VK_DYNAMIC_STATE_VIEWPORT,
+    eScissor = VK_DYNAMIC_STATE_SCISSOR,
+    eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
+    eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
+    eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
+    eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
+    eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
+    eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
+    eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
+    eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV,
+    eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT,
+    eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT,
+    eViewportShadingRatePaletteNV = VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV,
+    eViewportCoarseSampleOrderNV = VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV,
+    eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DynamicState value )
+  {
+    switch ( value )
+    {
+      case DynamicState::eViewport : return "Viewport";
+      case DynamicState::eScissor : return "Scissor";
+      case DynamicState::eLineWidth : return "LineWidth";
+      case DynamicState::eDepthBias : return "DepthBias";
+      case DynamicState::eBlendConstants : return "BlendConstants";
+      case DynamicState::eDepthBounds : return "DepthBounds";
+      case DynamicState::eStencilCompareMask : return "StencilCompareMask";
+      case DynamicState::eStencilWriteMask : return "StencilWriteMask";
+      case DynamicState::eStencilReference : return "StencilReference";
+      case DynamicState::eViewportWScalingNV : return "ViewportWScalingNV";
+      case DynamicState::eDiscardRectangleEXT : return "DiscardRectangleEXT";
+      case DynamicState::eSampleLocationsEXT : return "SampleLocationsEXT";
+      case DynamicState::eViewportShadingRatePaletteNV : return "ViewportShadingRatePaletteNV";
+      case DynamicState::eViewportCoarseSampleOrderNV : return "ViewportCoarseSampleOrderNV";
+      case DynamicState::eExclusiveScissorNV : return "ExclusiveScissorNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class Filter
+  {
+    eNearest = VK_FILTER_NEAREST,
+    eLinear = VK_FILTER_LINEAR,
+    eCubicIMG = VK_FILTER_CUBIC_IMG
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( Filter value )
+  {
+    switch ( value )
+    {
+      case Filter::eNearest : return "Nearest";
+      case Filter::eLinear : return "Linear";
+      case Filter::eCubicIMG : return "CubicIMG";
+      default: return "invalid";
+    }
+  }
 
   enum class Format
   {
@@ -8979,73 +3426,39 @@ public:
     eAstc12x12UnormBlock = VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
     eAstc12x12SrgbBlock = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
     eG8B8G8R8422Unorm = VK_FORMAT_G8B8G8R8_422_UNORM,
-    eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM,
     eB8G8R8G8422Unorm = VK_FORMAT_B8G8R8G8_422_UNORM,
-    eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM,
     eG8B8R83Plane420Unorm = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
-    eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
     eG8B8R82Plane420Unorm = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
-    eG8B8R82Plane420UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
     eG8B8R83Plane422Unorm = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
-    eG8B8R83Plane422UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
     eG8B8R82Plane422Unorm = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
-    eG8B8R82Plane422UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
     eG8B8R83Plane444Unorm = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
-    eG8B8R83Plane444UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
     eR10X6UnormPack16 = VK_FORMAT_R10X6_UNORM_PACK16,
-    eR10X6UnormPack16KHR = VK_FORMAT_R10X6_UNORM_PACK16,
     eR10X6G10X6Unorm2Pack16 = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
-    eR10X6G10X6Unorm2Pack16KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
     eR10X6G10X6B10X6A10X6Unorm4Pack16 = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
-    eR10X6G10X6B10X6A10X6Unorm4Pack16KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
     eG10X6B10X6G10X6R10X6422Unorm4Pack16 = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
-    eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
     eB10X6G10X6R10X6G10X6422Unorm4Pack16 = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
-    eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
     eG10X6B10X6R10X63Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
-    eG10X6B10X6R10X63Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
     eG10X6B10X6R10X62Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
-    eG10X6B10X6R10X62Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
     eG10X6B10X6R10X63Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
-    eG10X6B10X6R10X63Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
     eG10X6B10X6R10X62Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
-    eG10X6B10X6R10X62Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
     eG10X6B10X6R10X63Plane444Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
-    eG10X6B10X6R10X63Plane444Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
     eR12X4UnormPack16 = VK_FORMAT_R12X4_UNORM_PACK16,
-    eR12X4UnormPack16KHR = VK_FORMAT_R12X4_UNORM_PACK16,
     eR12X4G12X4Unorm2Pack16 = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
-    eR12X4G12X4Unorm2Pack16KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
     eR12X4G12X4B12X4A12X4Unorm4Pack16 = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
-    eR12X4G12X4B12X4A12X4Unorm4Pack16KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
     eG12X4B12X4G12X4R12X4422Unorm4Pack16 = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
-    eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
     eB12X4G12X4R12X4G12X4422Unorm4Pack16 = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
-    eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
     eG12X4B12X4R12X43Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
-    eG12X4B12X4R12X43Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
     eG12X4B12X4R12X42Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
-    eG12X4B12X4R12X42Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
     eG12X4B12X4R12X43Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
-    eG12X4B12X4R12X43Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
     eG12X4B12X4R12X42Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
-    eG12X4B12X4R12X42Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
     eG12X4B12X4R12X43Plane444Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
-    eG12X4B12X4R12X43Plane444Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
     eG16B16G16R16422Unorm = VK_FORMAT_G16B16G16R16_422_UNORM,
-    eG16B16G16R16422UnormKHR = VK_FORMAT_G16B16G16R16_422_UNORM,
     eB16G16R16G16422Unorm = VK_FORMAT_B16G16R16G16_422_UNORM,
-    eB16G16R16G16422UnormKHR = VK_FORMAT_B16G16R16G16_422_UNORM,
     eG16B16R163Plane420Unorm = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
-    eG16B16R163Plane420UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
     eG16B16R162Plane420Unorm = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
-    eG16B16R162Plane420UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
     eG16B16R163Plane422Unorm = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
-    eG16B16R163Plane422UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
     eG16B16R162Plane422Unorm = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
-    eG16B16R162Plane422UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
     eG16B16R163Plane444Unorm = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
-    eG16B16R163Plane444UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
     ePvrtc12BppUnormBlockIMG = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG,
     ePvrtc14BppUnormBlockIMG = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG,
     ePvrtc22BppUnormBlockIMG = VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG,
@@ -9053,85 +3466,1148 @@ public:
     ePvrtc12BppSrgbBlockIMG = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG,
     ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG,
     ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG,
-    ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG
+    ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG,
+    eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM_KHR,
+    eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM_KHR,
+    eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR,
+    eG8B8R82Plane420UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR,
+    eG8B8R83Plane422UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR,
+    eG8B8R82Plane422UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR,
+    eG8B8R83Plane444UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR,
+    eR10X6UnormPack16KHR = VK_FORMAT_R10X6_UNORM_PACK16_KHR,
+    eR10X6G10X6Unorm2Pack16KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR,
+    eR10X6G10X6B10X6A10X6Unorm4Pack16KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR,
+    eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR,
+    eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR,
+    eG10X6B10X6R10X63Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR,
+    eG10X6B10X6R10X62Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR,
+    eG10X6B10X6R10X63Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR,
+    eG10X6B10X6R10X62Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR,
+    eG10X6B10X6R10X63Plane444Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR,
+    eR12X4UnormPack16KHR = VK_FORMAT_R12X4_UNORM_PACK16_KHR,
+    eR12X4G12X4Unorm2Pack16KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR,
+    eR12X4G12X4B12X4A12X4Unorm4Pack16KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR,
+    eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR,
+    eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR,
+    eG12X4B12X4R12X43Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR,
+    eG12X4B12X4R12X42Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR,
+    eG12X4B12X4R12X43Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR,
+    eG12X4B12X4R12X42Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR,
+    eG12X4B12X4R12X43Plane444Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR,
+    eG16B16G16R16422UnormKHR = VK_FORMAT_G16B16G16R16_422_UNORM_KHR,
+    eB16G16R16G16422UnormKHR = VK_FORMAT_B16G16R16G16_422_UNORM_KHR,
+    eG16B16R163Plane420UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR,
+    eG16B16R162Plane420UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR,
+    eG16B16R163Plane422UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR,
+    eG16B16R162Plane422UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR,
+    eG16B16R163Plane444UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR
   };
 
-  struct VertexInputAttributeDescription
+  VULKAN_HPP_INLINE std::string to_string( Format value )
   {
-    VertexInputAttributeDescription( uint32_t location_ = 0,
-                                     uint32_t binding_ = 0,
-                                     Format format_ = Format::eUndefined,
-                                     uint32_t offset_ = 0 )
-      : location( location_ )
-      , binding( binding_ )
-      , format( format_ )
-      , offset( offset_ )
+    switch ( value )
     {
+      case Format::eUndefined : return "Undefined";
+      case Format::eR4G4UnormPack8 : return "R4G4UnormPack8";
+      case Format::eR4G4B4A4UnormPack16 : return "R4G4B4A4UnormPack16";
+      case Format::eB4G4R4A4UnormPack16 : return "B4G4R4A4UnormPack16";
+      case Format::eR5G6B5UnormPack16 : return "R5G6B5UnormPack16";
+      case Format::eB5G6R5UnormPack16 : return "B5G6R5UnormPack16";
+      case Format::eR5G5B5A1UnormPack16 : return "R5G5B5A1UnormPack16";
+      case Format::eB5G5R5A1UnormPack16 : return "B5G5R5A1UnormPack16";
+      case Format::eA1R5G5B5UnormPack16 : return "A1R5G5B5UnormPack16";
+      case Format::eR8Unorm : return "R8Unorm";
+      case Format::eR8Snorm : return "R8Snorm";
+      case Format::eR8Uscaled : return "R8Uscaled";
+      case Format::eR8Sscaled : return "R8Sscaled";
+      case Format::eR8Uint : return "R8Uint";
+      case Format::eR8Sint : return "R8Sint";
+      case Format::eR8Srgb : return "R8Srgb";
+      case Format::eR8G8Unorm : return "R8G8Unorm";
+      case Format::eR8G8Snorm : return "R8G8Snorm";
+      case Format::eR8G8Uscaled : return "R8G8Uscaled";
+      case Format::eR8G8Sscaled : return "R8G8Sscaled";
+      case Format::eR8G8Uint : return "R8G8Uint";
+      case Format::eR8G8Sint : return "R8G8Sint";
+      case Format::eR8G8Srgb : return "R8G8Srgb";
+      case Format::eR8G8B8Unorm : return "R8G8B8Unorm";
+      case Format::eR8G8B8Snorm : return "R8G8B8Snorm";
+      case Format::eR8G8B8Uscaled : return "R8G8B8Uscaled";
+      case Format::eR8G8B8Sscaled : return "R8G8B8Sscaled";
+      case Format::eR8G8B8Uint : return "R8G8B8Uint";
+      case Format::eR8G8B8Sint : return "R8G8B8Sint";
+      case Format::eR8G8B8Srgb : return "R8G8B8Srgb";
+      case Format::eB8G8R8Unorm : return "B8G8R8Unorm";
+      case Format::eB8G8R8Snorm : return "B8G8R8Snorm";
+      case Format::eB8G8R8Uscaled : return "B8G8R8Uscaled";
+      case Format::eB8G8R8Sscaled : return "B8G8R8Sscaled";
+      case Format::eB8G8R8Uint : return "B8G8R8Uint";
+      case Format::eB8G8R8Sint : return "B8G8R8Sint";
+      case Format::eB8G8R8Srgb : return "B8G8R8Srgb";
+      case Format::eR8G8B8A8Unorm : return "R8G8B8A8Unorm";
+      case Format::eR8G8B8A8Snorm : return "R8G8B8A8Snorm";
+      case Format::eR8G8B8A8Uscaled : return "R8G8B8A8Uscaled";
+      case Format::eR8G8B8A8Sscaled : return "R8G8B8A8Sscaled";
+      case Format::eR8G8B8A8Uint : return "R8G8B8A8Uint";
+      case Format::eR8G8B8A8Sint : return "R8G8B8A8Sint";
+      case Format::eR8G8B8A8Srgb : return "R8G8B8A8Srgb";
+      case Format::eB8G8R8A8Unorm : return "B8G8R8A8Unorm";
+      case Format::eB8G8R8A8Snorm : return "B8G8R8A8Snorm";
+      case Format::eB8G8R8A8Uscaled : return "B8G8R8A8Uscaled";
+      case Format::eB8G8R8A8Sscaled : return "B8G8R8A8Sscaled";
+      case Format::eB8G8R8A8Uint : return "B8G8R8A8Uint";
+      case Format::eB8G8R8A8Sint : return "B8G8R8A8Sint";
+      case Format::eB8G8R8A8Srgb : return "B8G8R8A8Srgb";
+      case Format::eA8B8G8R8UnormPack32 : return "A8B8G8R8UnormPack32";
+      case Format::eA8B8G8R8SnormPack32 : return "A8B8G8R8SnormPack32";
+      case Format::eA8B8G8R8UscaledPack32 : return "A8B8G8R8UscaledPack32";
+      case Format::eA8B8G8R8SscaledPack32 : return "A8B8G8R8SscaledPack32";
+      case Format::eA8B8G8R8UintPack32 : return "A8B8G8R8UintPack32";
+      case Format::eA8B8G8R8SintPack32 : return "A8B8G8R8SintPack32";
+      case Format::eA8B8G8R8SrgbPack32 : return "A8B8G8R8SrgbPack32";
+      case Format::eA2R10G10B10UnormPack32 : return "A2R10G10B10UnormPack32";
+      case Format::eA2R10G10B10SnormPack32 : return "A2R10G10B10SnormPack32";
+      case Format::eA2R10G10B10UscaledPack32 : return "A2R10G10B10UscaledPack32";
+      case Format::eA2R10G10B10SscaledPack32 : return "A2R10G10B10SscaledPack32";
+      case Format::eA2R10G10B10UintPack32 : return "A2R10G10B10UintPack32";
+      case Format::eA2R10G10B10SintPack32 : return "A2R10G10B10SintPack32";
+      case Format::eA2B10G10R10UnormPack32 : return "A2B10G10R10UnormPack32";
+      case Format::eA2B10G10R10SnormPack32 : return "A2B10G10R10SnormPack32";
+      case Format::eA2B10G10R10UscaledPack32 : return "A2B10G10R10UscaledPack32";
+      case Format::eA2B10G10R10SscaledPack32 : return "A2B10G10R10SscaledPack32";
+      case Format::eA2B10G10R10UintPack32 : return "A2B10G10R10UintPack32";
+      case Format::eA2B10G10R10SintPack32 : return "A2B10G10R10SintPack32";
+      case Format::eR16Unorm : return "R16Unorm";
+      case Format::eR16Snorm : return "R16Snorm";
+      case Format::eR16Uscaled : return "R16Uscaled";
+      case Format::eR16Sscaled : return "R16Sscaled";
+      case Format::eR16Uint : return "R16Uint";
+      case Format::eR16Sint : return "R16Sint";
+      case Format::eR16Sfloat : return "R16Sfloat";
+      case Format::eR16G16Unorm : return "R16G16Unorm";
+      case Format::eR16G16Snorm : return "R16G16Snorm";
+      case Format::eR16G16Uscaled : return "R16G16Uscaled";
+      case Format::eR16G16Sscaled : return "R16G16Sscaled";
+      case Format::eR16G16Uint : return "R16G16Uint";
+      case Format::eR16G16Sint : return "R16G16Sint";
+      case Format::eR16G16Sfloat : return "R16G16Sfloat";
+      case Format::eR16G16B16Unorm : return "R16G16B16Unorm";
+      case Format::eR16G16B16Snorm : return "R16G16B16Snorm";
+      case Format::eR16G16B16Uscaled : return "R16G16B16Uscaled";
+      case Format::eR16G16B16Sscaled : return "R16G16B16Sscaled";
+      case Format::eR16G16B16Uint : return "R16G16B16Uint";
+      case Format::eR16G16B16Sint : return "R16G16B16Sint";
+      case Format::eR16G16B16Sfloat : return "R16G16B16Sfloat";
+      case Format::eR16G16B16A16Unorm : return "R16G16B16A16Unorm";
+      case Format::eR16G16B16A16Snorm : return "R16G16B16A16Snorm";
+      case Format::eR16G16B16A16Uscaled : return "R16G16B16A16Uscaled";
+      case Format::eR16G16B16A16Sscaled : return "R16G16B16A16Sscaled";
+      case Format::eR16G16B16A16Uint : return "R16G16B16A16Uint";
+      case Format::eR16G16B16A16Sint : return "R16G16B16A16Sint";
+      case Format::eR16G16B16A16Sfloat : return "R16G16B16A16Sfloat";
+      case Format::eR32Uint : return "R32Uint";
+      case Format::eR32Sint : return "R32Sint";
+      case Format::eR32Sfloat : return "R32Sfloat";
+      case Format::eR32G32Uint : return "R32G32Uint";
+      case Format::eR32G32Sint : return "R32G32Sint";
+      case Format::eR32G32Sfloat : return "R32G32Sfloat";
+      case Format::eR32G32B32Uint : return "R32G32B32Uint";
+      case Format::eR32G32B32Sint : return "R32G32B32Sint";
+      case Format::eR32G32B32Sfloat : return "R32G32B32Sfloat";
+      case Format::eR32G32B32A32Uint : return "R32G32B32A32Uint";
+      case Format::eR32G32B32A32Sint : return "R32G32B32A32Sint";
+      case Format::eR32G32B32A32Sfloat : return "R32G32B32A32Sfloat";
+      case Format::eR64Uint : return "R64Uint";
+      case Format::eR64Sint : return "R64Sint";
+      case Format::eR64Sfloat : return "R64Sfloat";
+      case Format::eR64G64Uint : return "R64G64Uint";
+      case Format::eR64G64Sint : return "R64G64Sint";
+      case Format::eR64G64Sfloat : return "R64G64Sfloat";
+      case Format::eR64G64B64Uint : return "R64G64B64Uint";
+      case Format::eR64G64B64Sint : return "R64G64B64Sint";
+      case Format::eR64G64B64Sfloat : return "R64G64B64Sfloat";
+      case Format::eR64G64B64A64Uint : return "R64G64B64A64Uint";
+      case Format::eR64G64B64A64Sint : return "R64G64B64A64Sint";
+      case Format::eR64G64B64A64Sfloat : return "R64G64B64A64Sfloat";
+      case Format::eB10G11R11UfloatPack32 : return "B10G11R11UfloatPack32";
+      case Format::eE5B9G9R9UfloatPack32 : return "E5B9G9R9UfloatPack32";
+      case Format::eD16Unorm : return "D16Unorm";
+      case Format::eX8D24UnormPack32 : return "X8D24UnormPack32";
+      case Format::eD32Sfloat : return "D32Sfloat";
+      case Format::eS8Uint : return "S8Uint";
+      case Format::eD16UnormS8Uint : return "D16UnormS8Uint";
+      case Format::eD24UnormS8Uint : return "D24UnormS8Uint";
+      case Format::eD32SfloatS8Uint : return "D32SfloatS8Uint";
+      case Format::eBc1RgbUnormBlock : return "Bc1RgbUnormBlock";
+      case Format::eBc1RgbSrgbBlock : return "Bc1RgbSrgbBlock";
+      case Format::eBc1RgbaUnormBlock : return "Bc1RgbaUnormBlock";
+      case Format::eBc1RgbaSrgbBlock : return "Bc1RgbaSrgbBlock";
+      case Format::eBc2UnormBlock : return "Bc2UnormBlock";
+      case Format::eBc2SrgbBlock : return "Bc2SrgbBlock";
+      case Format::eBc3UnormBlock : return "Bc3UnormBlock";
+      case Format::eBc3SrgbBlock : return "Bc3SrgbBlock";
+      case Format::eBc4UnormBlock : return "Bc4UnormBlock";
+      case Format::eBc4SnormBlock : return "Bc4SnormBlock";
+      case Format::eBc5UnormBlock : return "Bc5UnormBlock";
+      case Format::eBc5SnormBlock : return "Bc5SnormBlock";
+      case Format::eBc6HUfloatBlock : return "Bc6HUfloatBlock";
+      case Format::eBc6HSfloatBlock : return "Bc6HSfloatBlock";
+      case Format::eBc7UnormBlock : return "Bc7UnormBlock";
+      case Format::eBc7SrgbBlock : return "Bc7SrgbBlock";
+      case Format::eEtc2R8G8B8UnormBlock : return "Etc2R8G8B8UnormBlock";
+      case Format::eEtc2R8G8B8SrgbBlock : return "Etc2R8G8B8SrgbBlock";
+      case Format::eEtc2R8G8B8A1UnormBlock : return "Etc2R8G8B8A1UnormBlock";
+      case Format::eEtc2R8G8B8A1SrgbBlock : return "Etc2R8G8B8A1SrgbBlock";
+      case Format::eEtc2R8G8B8A8UnormBlock : return "Etc2R8G8B8A8UnormBlock";
+      case Format::eEtc2R8G8B8A8SrgbBlock : return "Etc2R8G8B8A8SrgbBlock";
+      case Format::eEacR11UnormBlock : return "EacR11UnormBlock";
+      case Format::eEacR11SnormBlock : return "EacR11SnormBlock";
+      case Format::eEacR11G11UnormBlock : return "EacR11G11UnormBlock";
+      case Format::eEacR11G11SnormBlock : return "EacR11G11SnormBlock";
+      case Format::eAstc4x4UnormBlock : return "Astc4x4UnormBlock";
+      case Format::eAstc4x4SrgbBlock : return "Astc4x4SrgbBlock";
+      case Format::eAstc5x4UnormBlock : return "Astc5x4UnormBlock";
+      case Format::eAstc5x4SrgbBlock : return "Astc5x4SrgbBlock";
+      case Format::eAstc5x5UnormBlock : return "Astc5x5UnormBlock";
+      case Format::eAstc5x5SrgbBlock : return "Astc5x5SrgbBlock";
+      case Format::eAstc6x5UnormBlock : return "Astc6x5UnormBlock";
+      case Format::eAstc6x5SrgbBlock : return "Astc6x5SrgbBlock";
+      case Format::eAstc6x6UnormBlock : return "Astc6x6UnormBlock";
+      case Format::eAstc6x6SrgbBlock : return "Astc6x6SrgbBlock";
+      case Format::eAstc8x5UnormBlock : return "Astc8x5UnormBlock";
+      case Format::eAstc8x5SrgbBlock : return "Astc8x5SrgbBlock";
+      case Format::eAstc8x6UnormBlock : return "Astc8x6UnormBlock";
+      case Format::eAstc8x6SrgbBlock : return "Astc8x6SrgbBlock";
+      case Format::eAstc8x8UnormBlock : return "Astc8x8UnormBlock";
+      case Format::eAstc8x8SrgbBlock : return "Astc8x8SrgbBlock";
+      case Format::eAstc10x5UnormBlock : return "Astc10x5UnormBlock";
+      case Format::eAstc10x5SrgbBlock : return "Astc10x5SrgbBlock";
+      case Format::eAstc10x6UnormBlock : return "Astc10x6UnormBlock";
+      case Format::eAstc10x6SrgbBlock : return "Astc10x6SrgbBlock";
+      case Format::eAstc10x8UnormBlock : return "Astc10x8UnormBlock";
+      case Format::eAstc10x8SrgbBlock : return "Astc10x8SrgbBlock";
+      case Format::eAstc10x10UnormBlock : return "Astc10x10UnormBlock";
+      case Format::eAstc10x10SrgbBlock : return "Astc10x10SrgbBlock";
+      case Format::eAstc12x10UnormBlock : return "Astc12x10UnormBlock";
+      case Format::eAstc12x10SrgbBlock : return "Astc12x10SrgbBlock";
+      case Format::eAstc12x12UnormBlock : return "Astc12x12UnormBlock";
+      case Format::eAstc12x12SrgbBlock : return "Astc12x12SrgbBlock";
+      case Format::eG8B8G8R8422Unorm : return "G8B8G8R8422Unorm";
+      case Format::eB8G8R8G8422Unorm : return "B8G8R8G8422Unorm";
+      case Format::eG8B8R83Plane420Unorm : return "G8B8R83Plane420Unorm";
+      case Format::eG8B8R82Plane420Unorm : return "G8B8R82Plane420Unorm";
+      case Format::eG8B8R83Plane422Unorm : return "G8B8R83Plane422Unorm";
+      case Format::eG8B8R82Plane422Unorm : return "G8B8R82Plane422Unorm";
+      case Format::eG8B8R83Plane444Unorm : return "G8B8R83Plane444Unorm";
+      case Format::eR10X6UnormPack16 : return "R10X6UnormPack16";
+      case Format::eR10X6G10X6Unorm2Pack16 : return "R10X6G10X6Unorm2Pack16";
+      case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return "R10X6G10X6B10X6A10X6Unorm4Pack16";
+      case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return "G10X6B10X6G10X6R10X6422Unorm4Pack16";
+      case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return "B10X6G10X6R10X6G10X6422Unorm4Pack16";
+      case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return "G10X6B10X6R10X63Plane420Unorm3Pack16";
+      case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return "G10X6B10X6R10X62Plane420Unorm3Pack16";
+      case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return "G10X6B10X6R10X63Plane422Unorm3Pack16";
+      case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return "G10X6B10X6R10X62Plane422Unorm3Pack16";
+      case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return "G10X6B10X6R10X63Plane444Unorm3Pack16";
+      case Format::eR12X4UnormPack16 : return "R12X4UnormPack16";
+      case Format::eR12X4G12X4Unorm2Pack16 : return "R12X4G12X4Unorm2Pack16";
+      case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return "R12X4G12X4B12X4A12X4Unorm4Pack16";
+      case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return "G12X4B12X4G12X4R12X4422Unorm4Pack16";
+      case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return "B12X4G12X4R12X4G12X4422Unorm4Pack16";
+      case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return "G12X4B12X4R12X43Plane420Unorm3Pack16";
+      case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return "G12X4B12X4R12X42Plane420Unorm3Pack16";
+      case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return "G12X4B12X4R12X43Plane422Unorm3Pack16";
+      case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return "G12X4B12X4R12X42Plane422Unorm3Pack16";
+      case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return "G12X4B12X4R12X43Plane444Unorm3Pack16";
+      case Format::eG16B16G16R16422Unorm : return "G16B16G16R16422Unorm";
+      case Format::eB16G16R16G16422Unorm : return "B16G16R16G16422Unorm";
+      case Format::eG16B16R163Plane420Unorm : return "G16B16R163Plane420Unorm";
+      case Format::eG16B16R162Plane420Unorm : return "G16B16R162Plane420Unorm";
+      case Format::eG16B16R163Plane422Unorm : return "G16B16R163Plane422Unorm";
+      case Format::eG16B16R162Plane422Unorm : return "G16B16R162Plane422Unorm";
+      case Format::eG16B16R163Plane444Unorm : return "G16B16R163Plane444Unorm";
+      case Format::ePvrtc12BppUnormBlockIMG : return "Pvrtc12BppUnormBlockIMG";
+      case Format::ePvrtc14BppUnormBlockIMG : return "Pvrtc14BppUnormBlockIMG";
+      case Format::ePvrtc22BppUnormBlockIMG : return "Pvrtc22BppUnormBlockIMG";
+      case Format::ePvrtc24BppUnormBlockIMG : return "Pvrtc24BppUnormBlockIMG";
+      case Format::ePvrtc12BppSrgbBlockIMG : return "Pvrtc12BppSrgbBlockIMG";
+      case Format::ePvrtc14BppSrgbBlockIMG : return "Pvrtc14BppSrgbBlockIMG";
+      case Format::ePvrtc22BppSrgbBlockIMG : return "Pvrtc22BppSrgbBlockIMG";
+      case Format::ePvrtc24BppSrgbBlockIMG : return "Pvrtc24BppSrgbBlockIMG";
+      default: return "invalid";
     }
+  }
 
-    VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
-    }
-
-    VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
-      return *this;
-    }
-    VertexInputAttributeDescription& setLocation( uint32_t location_ )
-    {
-      location = location_;
-      return *this;
-    }
-
-    VertexInputAttributeDescription& setBinding( uint32_t binding_ )
-    {
-      binding = binding_;
-      return *this;
-    }
-
-    VertexInputAttributeDescription& setFormat( Format format_ )
-    {
-      format = format_;
-      return *this;
-    }
-
-    VertexInputAttributeDescription& setOffset( uint32_t offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    operator VkVertexInputAttributeDescription const&() const
-    {
-      return *reinterpret_cast<const VkVertexInputAttributeDescription*>(this);
-    }
-
-    operator VkVertexInputAttributeDescription &()
-    {
-      return *reinterpret_cast<VkVertexInputAttributeDescription*>(this);
-    }
-
-    bool operator==( VertexInputAttributeDescription const& rhs ) const
-    {
-      return ( location == rhs.location )
-          && ( binding == rhs.binding )
-          && ( format == rhs.format )
-          && ( offset == rhs.offset );
-    }
-
-    bool operator!=( VertexInputAttributeDescription const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t location;
-    uint32_t binding;
-    Format format;
-    uint32_t offset;
+  enum class FrontFace
+  {
+    eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE,
+    eClockwise = VK_FRONT_FACE_CLOCKWISE
   };
-  static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" );
+
+  VULKAN_HPP_INLINE std::string to_string( FrontFace value )
+  {
+    switch ( value )
+    {
+      case FrontFace::eCounterClockwise : return "CounterClockwise";
+      case FrontFace::eClockwise : return "Clockwise";
+      default: return "invalid";
+    }
+  }
+
+  enum class GeometryTypeNV
+  {
+    eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_NV,
+    eAabbs = VK_GEOMETRY_TYPE_AABBS_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( GeometryTypeNV value )
+  {
+    switch ( value )
+    {
+      case GeometryTypeNV::eTriangles : return "Triangles";
+      case GeometryTypeNV::eAabbs : return "Aabbs";
+      default: return "invalid";
+    }
+  }
+
+  enum class ImageLayout
+  {
+    eUndefined = VK_IMAGE_LAYOUT_UNDEFINED,
+    eGeneral = VK_IMAGE_LAYOUT_GENERAL,
+    eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+    eDepthStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+    eDepthStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
+    eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+    eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+    eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+    ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED,
+    eDepthReadOnlyStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
+    eDepthAttachmentStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
+    ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+    eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR,
+    eShadingRateOptimalNV = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV,
+    eFragmentDensityMapOptimalEXT = VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT,
+    eDepthReadOnlyStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR,
+    eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageLayout value )
+  {
+    switch ( value )
+    {
+      case ImageLayout::eUndefined : return "Undefined";
+      case ImageLayout::eGeneral : return "General";
+      case ImageLayout::eColorAttachmentOptimal : return "ColorAttachmentOptimal";
+      case ImageLayout::eDepthStencilAttachmentOptimal : return "DepthStencilAttachmentOptimal";
+      case ImageLayout::eDepthStencilReadOnlyOptimal : return "DepthStencilReadOnlyOptimal";
+      case ImageLayout::eShaderReadOnlyOptimal : return "ShaderReadOnlyOptimal";
+      case ImageLayout::eTransferSrcOptimal : return "TransferSrcOptimal";
+      case ImageLayout::eTransferDstOptimal : return "TransferDstOptimal";
+      case ImageLayout::ePreinitialized : return "Preinitialized";
+      case ImageLayout::eDepthReadOnlyStencilAttachmentOptimal : return "DepthReadOnlyStencilAttachmentOptimal";
+      case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal : return "DepthAttachmentStencilReadOnlyOptimal";
+      case ImageLayout::ePresentSrcKHR : return "PresentSrcKHR";
+      case ImageLayout::eSharedPresentKHR : return "SharedPresentKHR";
+      case ImageLayout::eShadingRateOptimalNV : return "ShadingRateOptimalNV";
+      case ImageLayout::eFragmentDensityMapOptimalEXT : return "FragmentDensityMapOptimalEXT";
+      default: return "invalid";
+    }
+  }
+
+  enum class ImageTiling
+  {
+    eOptimal = VK_IMAGE_TILING_OPTIMAL,
+    eLinear = VK_IMAGE_TILING_LINEAR,
+    eDrmFormatModifierEXT = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageTiling value )
+  {
+    switch ( value )
+    {
+      case ImageTiling::eOptimal : return "Optimal";
+      case ImageTiling::eLinear : return "Linear";
+      case ImageTiling::eDrmFormatModifierEXT : return "DrmFormatModifierEXT";
+      default: return "invalid";
+    }
+  }
+
+  enum class ImageType
+  {
+    e1D = VK_IMAGE_TYPE_1D,
+    e2D = VK_IMAGE_TYPE_2D,
+    e3D = VK_IMAGE_TYPE_3D
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageType value )
+  {
+    switch ( value )
+    {
+      case ImageType::e1D : return "1D";
+      case ImageType::e2D : return "2D";
+      case ImageType::e3D : return "3D";
+      default: return "invalid";
+    }
+  }
+
+  enum class ImageViewType
+  {
+    e1D = VK_IMAGE_VIEW_TYPE_1D,
+    e2D = VK_IMAGE_VIEW_TYPE_2D,
+    e3D = VK_IMAGE_VIEW_TYPE_3D,
+    eCube = VK_IMAGE_VIEW_TYPE_CUBE,
+    e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY,
+    e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY,
+    eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageViewType value )
+  {
+    switch ( value )
+    {
+      case ImageViewType::e1D : return "1D";
+      case ImageViewType::e2D : return "2D";
+      case ImageViewType::e3D : return "3D";
+      case ImageViewType::eCube : return "Cube";
+      case ImageViewType::e1DArray : return "1DArray";
+      case ImageViewType::e2DArray : return "2DArray";
+      case ImageViewType::eCubeArray : return "CubeArray";
+      default: return "invalid";
+    }
+  }
+
+  enum class IndexType
+  {
+    eUint16 = VK_INDEX_TYPE_UINT16,
+    eUint32 = VK_INDEX_TYPE_UINT32,
+    eNoneNV = VK_INDEX_TYPE_NONE_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( IndexType value )
+  {
+    switch ( value )
+    {
+      case IndexType::eUint16 : return "Uint16";
+      case IndexType::eUint32 : return "Uint32";
+      case IndexType::eNoneNV : return "NoneNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class IndirectCommandsTokenTypeNVX
+  {
+    ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX,
+    eDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX,
+    eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX,
+    eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX,
+    ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX,
+    eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX,
+    eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX,
+    eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( IndirectCommandsTokenTypeNVX value )
+  {
+    switch ( value )
+    {
+      case IndirectCommandsTokenTypeNVX::ePipeline : return "Pipeline";
+      case IndirectCommandsTokenTypeNVX::eDescriptorSet : return "DescriptorSet";
+      case IndirectCommandsTokenTypeNVX::eIndexBuffer : return "IndexBuffer";
+      case IndirectCommandsTokenTypeNVX::eVertexBuffer : return "VertexBuffer";
+      case IndirectCommandsTokenTypeNVX::ePushConstant : return "PushConstant";
+      case IndirectCommandsTokenTypeNVX::eDrawIndexed : return "DrawIndexed";
+      case IndirectCommandsTokenTypeNVX::eDraw : return "Draw";
+      case IndirectCommandsTokenTypeNVX::eDispatch : return "Dispatch";
+      default: return "invalid";
+    }
+  }
+
+  enum class InternalAllocationType
+  {
+    eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( InternalAllocationType value )
+  {
+    switch ( value )
+    {
+      case InternalAllocationType::eExecutable : return "Executable";
+      default: return "invalid";
+    }
+  }
+
+  enum class LogicOp
+  {
+    eClear = VK_LOGIC_OP_CLEAR,
+    eAnd = VK_LOGIC_OP_AND,
+    eAndReverse = VK_LOGIC_OP_AND_REVERSE,
+    eCopy = VK_LOGIC_OP_COPY,
+    eAndInverted = VK_LOGIC_OP_AND_INVERTED,
+    eNoOp = VK_LOGIC_OP_NO_OP,
+    eXor = VK_LOGIC_OP_XOR,
+    eOr = VK_LOGIC_OP_OR,
+    eNor = VK_LOGIC_OP_NOR,
+    eEquivalent = VK_LOGIC_OP_EQUIVALENT,
+    eInvert = VK_LOGIC_OP_INVERT,
+    eOrReverse = VK_LOGIC_OP_OR_REVERSE,
+    eCopyInverted = VK_LOGIC_OP_COPY_INVERTED,
+    eOrInverted = VK_LOGIC_OP_OR_INVERTED,
+    eNand = VK_LOGIC_OP_NAND,
+    eSet = VK_LOGIC_OP_SET
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( LogicOp value )
+  {
+    switch ( value )
+    {
+      case LogicOp::eClear : return "Clear";
+      case LogicOp::eAnd : return "And";
+      case LogicOp::eAndReverse : return "AndReverse";
+      case LogicOp::eCopy : return "Copy";
+      case LogicOp::eAndInverted : return "AndInverted";
+      case LogicOp::eNoOp : return "NoOp";
+      case LogicOp::eXor : return "Xor";
+      case LogicOp::eOr : return "Or";
+      case LogicOp::eNor : return "Nor";
+      case LogicOp::eEquivalent : return "Equivalent";
+      case LogicOp::eInvert : return "Invert";
+      case LogicOp::eOrReverse : return "OrReverse";
+      case LogicOp::eCopyInverted : return "CopyInverted";
+      case LogicOp::eOrInverted : return "OrInverted";
+      case LogicOp::eNand : return "Nand";
+      case LogicOp::eSet : return "Set";
+      default: return "invalid";
+    }
+  }
+
+  enum class MemoryOverallocationBehaviorAMD
+  {
+    eDefault = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD,
+    eAllowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD,
+    eDisallowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( MemoryOverallocationBehaviorAMD value )
+  {
+    switch ( value )
+    {
+      case MemoryOverallocationBehaviorAMD::eDefault : return "Default";
+      case MemoryOverallocationBehaviorAMD::eAllowed : return "Allowed";
+      case MemoryOverallocationBehaviorAMD::eDisallowed : return "Disallowed";
+      default: return "invalid";
+    }
+  }
+
+  enum class ObjectEntryTypeNVX
+  {
+    eDescriptorSet = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX,
+    ePipeline = VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX,
+    eIndexBuffer = VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX,
+    eVertexBuffer = VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX,
+    ePushConstant = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ObjectEntryTypeNVX value )
+  {
+    switch ( value )
+    {
+      case ObjectEntryTypeNVX::eDescriptorSet : return "DescriptorSet";
+      case ObjectEntryTypeNVX::ePipeline : return "Pipeline";
+      case ObjectEntryTypeNVX::eIndexBuffer : return "IndexBuffer";
+      case ObjectEntryTypeNVX::eVertexBuffer : return "VertexBuffer";
+      case ObjectEntryTypeNVX::ePushConstant : return "PushConstant";
+      default: return "invalid";
+    }
+  }
+
+  enum class ObjectType
+  {
+    eUnknown = VK_OBJECT_TYPE_UNKNOWN,
+    eInstance = VK_OBJECT_TYPE_INSTANCE,
+    ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE,
+    eDevice = VK_OBJECT_TYPE_DEVICE,
+    eQueue = VK_OBJECT_TYPE_QUEUE,
+    eSemaphore = VK_OBJECT_TYPE_SEMAPHORE,
+    eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER,
+    eFence = VK_OBJECT_TYPE_FENCE,
+    eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY,
+    eBuffer = VK_OBJECT_TYPE_BUFFER,
+    eImage = VK_OBJECT_TYPE_IMAGE,
+    eEvent = VK_OBJECT_TYPE_EVENT,
+    eQueryPool = VK_OBJECT_TYPE_QUERY_POOL,
+    eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW,
+    eImageView = VK_OBJECT_TYPE_IMAGE_VIEW,
+    eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE,
+    ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE,
+    ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT,
+    eRenderPass = VK_OBJECT_TYPE_RENDER_PASS,
+    ePipeline = VK_OBJECT_TYPE_PIPELINE,
+    eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
+    eSampler = VK_OBJECT_TYPE_SAMPLER,
+    eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL,
+    eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET,
+    eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER,
+    eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL,
+    eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
+    eDescriptorUpdateTemplate = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
+    eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR,
+    eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR,
+    eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR,
+    eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR,
+    eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT,
+    eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX,
+    eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX,
+    eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT,
+    eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT,
+    eAccelerationStructureNV = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV,
+    eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR,
+    eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ObjectType value )
+  {
+    switch ( value )
+    {
+      case ObjectType::eUnknown : return "Unknown";
+      case ObjectType::eInstance : return "Instance";
+      case ObjectType::ePhysicalDevice : return "PhysicalDevice";
+      case ObjectType::eDevice : return "Device";
+      case ObjectType::eQueue : return "Queue";
+      case ObjectType::eSemaphore : return "Semaphore";
+      case ObjectType::eCommandBuffer : return "CommandBuffer";
+      case ObjectType::eFence : return "Fence";
+      case ObjectType::eDeviceMemory : return "DeviceMemory";
+      case ObjectType::eBuffer : return "Buffer";
+      case ObjectType::eImage : return "Image";
+      case ObjectType::eEvent : return "Event";
+      case ObjectType::eQueryPool : return "QueryPool";
+      case ObjectType::eBufferView : return "BufferView";
+      case ObjectType::eImageView : return "ImageView";
+      case ObjectType::eShaderModule : return "ShaderModule";
+      case ObjectType::ePipelineCache : return "PipelineCache";
+      case ObjectType::ePipelineLayout : return "PipelineLayout";
+      case ObjectType::eRenderPass : return "RenderPass";
+      case ObjectType::ePipeline : return "Pipeline";
+      case ObjectType::eDescriptorSetLayout : return "DescriptorSetLayout";
+      case ObjectType::eSampler : return "Sampler";
+      case ObjectType::eDescriptorPool : return "DescriptorPool";
+      case ObjectType::eDescriptorSet : return "DescriptorSet";
+      case ObjectType::eFramebuffer : return "Framebuffer";
+      case ObjectType::eCommandPool : return "CommandPool";
+      case ObjectType::eSamplerYcbcrConversion : return "SamplerYcbcrConversion";
+      case ObjectType::eDescriptorUpdateTemplate : return "DescriptorUpdateTemplate";
+      case ObjectType::eSurfaceKHR : return "SurfaceKHR";
+      case ObjectType::eSwapchainKHR : return "SwapchainKHR";
+      case ObjectType::eDisplayKHR : return "DisplayKHR";
+      case ObjectType::eDisplayModeKHR : return "DisplayModeKHR";
+      case ObjectType::eDebugReportCallbackEXT : return "DebugReportCallbackEXT";
+      case ObjectType::eObjectTableNVX : return "ObjectTableNVX";
+      case ObjectType::eIndirectCommandsLayoutNVX : return "IndirectCommandsLayoutNVX";
+      case ObjectType::eDebugUtilsMessengerEXT : return "DebugUtilsMessengerEXT";
+      case ObjectType::eValidationCacheEXT : return "ValidationCacheEXT";
+      case ObjectType::eAccelerationStructureNV : return "AccelerationStructureNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class PhysicalDeviceType
+  {
+    eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER,
+    eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
+    eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
+    eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU,
+    eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PhysicalDeviceType value )
+  {
+    switch ( value )
+    {
+      case PhysicalDeviceType::eOther : return "Other";
+      case PhysicalDeviceType::eIntegratedGpu : return "IntegratedGpu";
+      case PhysicalDeviceType::eDiscreteGpu : return "DiscreteGpu";
+      case PhysicalDeviceType::eVirtualGpu : return "VirtualGpu";
+      case PhysicalDeviceType::eCpu : return "Cpu";
+      default: return "invalid";
+    }
+  }
+
+  enum class PipelineBindPoint
+  {
+    eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS,
+    eCompute = VK_PIPELINE_BIND_POINT_COMPUTE,
+    eRayTracingNV = VK_PIPELINE_BIND_POINT_RAY_TRACING_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineBindPoint value )
+  {
+    switch ( value )
+    {
+      case PipelineBindPoint::eGraphics : return "Graphics";
+      case PipelineBindPoint::eCompute : return "Compute";
+      case PipelineBindPoint::eRayTracingNV : return "RayTracingNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class PipelineCacheHeaderVersion
+  {
+    eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCacheHeaderVersion value )
+  {
+    switch ( value )
+    {
+      case PipelineCacheHeaderVersion::eOne : return "One";
+      default: return "invalid";
+    }
+  }
+
+  enum class PointClippingBehavior
+  {
+    eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
+    eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
+    eAllClipPlanesKHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR,
+    eUserClipPlanesOnlyKHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PointClippingBehavior value )
+  {
+    switch ( value )
+    {
+      case PointClippingBehavior::eAllClipPlanes : return "AllClipPlanes";
+      case PointClippingBehavior::eUserClipPlanesOnly : return "UserClipPlanesOnly";
+      default: return "invalid";
+    }
+  }
+
+  enum class PolygonMode
+  {
+    eFill = VK_POLYGON_MODE_FILL,
+    eLine = VK_POLYGON_MODE_LINE,
+    ePoint = VK_POLYGON_MODE_POINT,
+    eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PolygonMode value )
+  {
+    switch ( value )
+    {
+      case PolygonMode::eFill : return "Fill";
+      case PolygonMode::eLine : return "Line";
+      case PolygonMode::ePoint : return "Point";
+      case PolygonMode::eFillRectangleNV : return "FillRectangleNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class PresentModeKHR
+  {
+    eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR,
+    eMailbox = VK_PRESENT_MODE_MAILBOX_KHR,
+    eFifo = VK_PRESENT_MODE_FIFO_KHR,
+    eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
+    eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR,
+    eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PresentModeKHR value )
+  {
+    switch ( value )
+    {
+      case PresentModeKHR::eImmediate : return "Immediate";
+      case PresentModeKHR::eMailbox : return "Mailbox";
+      case PresentModeKHR::eFifo : return "Fifo";
+      case PresentModeKHR::eFifoRelaxed : return "FifoRelaxed";
+      case PresentModeKHR::eSharedDemandRefresh : return "SharedDemandRefresh";
+      case PresentModeKHR::eSharedContinuousRefresh : return "SharedContinuousRefresh";
+      default: return "invalid";
+    }
+  }
+
+  enum class PrimitiveTopology
+  {
+    ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
+    eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST,
+    eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
+    eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
+    eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
+    eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,
+    eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY,
+    eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY,
+    eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY,
+    eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY,
+    ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PrimitiveTopology value )
+  {
+    switch ( value )
+    {
+      case PrimitiveTopology::ePointList : return "PointList";
+      case PrimitiveTopology::eLineList : return "LineList";
+      case PrimitiveTopology::eLineStrip : return "LineStrip";
+      case PrimitiveTopology::eTriangleList : return "TriangleList";
+      case PrimitiveTopology::eTriangleStrip : return "TriangleStrip";
+      case PrimitiveTopology::eTriangleFan : return "TriangleFan";
+      case PrimitiveTopology::eLineListWithAdjacency : return "LineListWithAdjacency";
+      case PrimitiveTopology::eLineStripWithAdjacency : return "LineStripWithAdjacency";
+      case PrimitiveTopology::eTriangleListWithAdjacency : return "TriangleListWithAdjacency";
+      case PrimitiveTopology::eTriangleStripWithAdjacency : return "TriangleStripWithAdjacency";
+      case PrimitiveTopology::ePatchList : return "PatchList";
+      default: return "invalid";
+    }
+  }
+
+  enum class QueryType
+  {
+    eOcclusion = VK_QUERY_TYPE_OCCLUSION,
+    ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
+    eTimestamp = VK_QUERY_TYPE_TIMESTAMP,
+    eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT,
+    eAccelerationStructureCompactedSizeNV = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( QueryType value )
+  {
+    switch ( value )
+    {
+      case QueryType::eOcclusion : return "Occlusion";
+      case QueryType::ePipelineStatistics : return "PipelineStatistics";
+      case QueryType::eTimestamp : return "Timestamp";
+      case QueryType::eTransformFeedbackStreamEXT : return "TransformFeedbackStreamEXT";
+      case QueryType::eAccelerationStructureCompactedSizeNV : return "AccelerationStructureCompactedSizeNV";
+      default: return "invalid";
+    }
+  }
+
+  enum class QueueGlobalPriorityEXT
+  {
+    eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT,
+    eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT,
+    eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT,
+    eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( QueueGlobalPriorityEXT value )
+  {
+    switch ( value )
+    {
+      case QueueGlobalPriorityEXT::eLow : return "Low";
+      case QueueGlobalPriorityEXT::eMedium : return "Medium";
+      case QueueGlobalPriorityEXT::eHigh : return "High";
+      case QueueGlobalPriorityEXT::eRealtime : return "Realtime";
+      default: return "invalid";
+    }
+  }
+
+  enum class RasterizationOrderAMD
+  {
+    eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD,
+    eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( RasterizationOrderAMD value )
+  {
+    switch ( value )
+    {
+      case RasterizationOrderAMD::eStrict : return "Strict";
+      case RasterizationOrderAMD::eRelaxed : return "Relaxed";
+      default: return "invalid";
+    }
+  }
+
+  enum class RayTracingShaderGroupTypeNV
+  {
+    eGeneral = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV,
+    eTrianglesHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV,
+    eProceduralHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( RayTracingShaderGroupTypeNV value )
+  {
+    switch ( value )
+    {
+      case RayTracingShaderGroupTypeNV::eGeneral : return "General";
+      case RayTracingShaderGroupTypeNV::eTrianglesHitGroup : return "TrianglesHitGroup";
+      case RayTracingShaderGroupTypeNV::eProceduralHitGroup : return "ProceduralHitGroup";
+      default: return "invalid";
+    }
+  }
+
+  enum class Result
+  {
+    eSuccess = VK_SUCCESS,
+    eNotReady = VK_NOT_READY,
+    eTimeout = VK_TIMEOUT,
+    eEventSet = VK_EVENT_SET,
+    eEventReset = VK_EVENT_RESET,
+    eIncomplete = VK_INCOMPLETE,
+    eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY,
+    eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY,
+    eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED,
+    eErrorDeviceLost = VK_ERROR_DEVICE_LOST,
+    eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED,
+    eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT,
+    eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT,
+    eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT,
+    eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER,
+    eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS,
+    eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED,
+    eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL,
+    eErrorOutOfPoolMemory = VK_ERROR_OUT_OF_POOL_MEMORY,
+    eErrorInvalidExternalHandle = VK_ERROR_INVALID_EXTERNAL_HANDLE,
+    eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR,
+    eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR,
+    eSuboptimalKHR = VK_SUBOPTIMAL_KHR,
+    eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR,
+    eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR,
+    eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT,
+    eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV,
+    eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT,
+    eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT,
+    eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT,
+    eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR,
+    eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( Result value )
+  {
+    switch ( value )
+    {
+      case Result::eSuccess : return "Success";
+      case Result::eNotReady : return "NotReady";
+      case Result::eTimeout : return "Timeout";
+      case Result::eEventSet : return "EventSet";
+      case Result::eEventReset : return "EventReset";
+      case Result::eIncomplete : return "Incomplete";
+      case Result::eErrorOutOfHostMemory : return "ErrorOutOfHostMemory";
+      case Result::eErrorOutOfDeviceMemory : return "ErrorOutOfDeviceMemory";
+      case Result::eErrorInitializationFailed : return "ErrorInitializationFailed";
+      case Result::eErrorDeviceLost : return "ErrorDeviceLost";
+      case Result::eErrorMemoryMapFailed : return "ErrorMemoryMapFailed";
+      case Result::eErrorLayerNotPresent : return "ErrorLayerNotPresent";
+      case Result::eErrorExtensionNotPresent : return "ErrorExtensionNotPresent";
+      case Result::eErrorFeatureNotPresent : return "ErrorFeatureNotPresent";
+      case Result::eErrorIncompatibleDriver : return "ErrorIncompatibleDriver";
+      case Result::eErrorTooManyObjects : return "ErrorTooManyObjects";
+      case Result::eErrorFormatNotSupported : return "ErrorFormatNotSupported";
+      case Result::eErrorFragmentedPool : return "ErrorFragmentedPool";
+      case Result::eErrorOutOfPoolMemory : return "ErrorOutOfPoolMemory";
+      case Result::eErrorInvalidExternalHandle : return "ErrorInvalidExternalHandle";
+      case Result::eErrorSurfaceLostKHR : return "ErrorSurfaceLostKHR";
+      case Result::eErrorNativeWindowInUseKHR : return "ErrorNativeWindowInUseKHR";
+      case Result::eSuboptimalKHR : return "SuboptimalKHR";
+      case Result::eErrorOutOfDateKHR : return "ErrorOutOfDateKHR";
+      case Result::eErrorIncompatibleDisplayKHR : return "ErrorIncompatibleDisplayKHR";
+      case Result::eErrorValidationFailedEXT : return "ErrorValidationFailedEXT";
+      case Result::eErrorInvalidShaderNV : return "ErrorInvalidShaderNV";
+      case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT : return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT";
+      case Result::eErrorFragmentationEXT : return "ErrorFragmentationEXT";
+      case Result::eErrorNotPermittedEXT : return "ErrorNotPermittedEXT";
+      default: return "invalid";
+    }
+  }
+
+  enum class SamplerAddressMode
+  {
+    eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT,
+    eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
+    eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+    eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
+    eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SamplerAddressMode value )
+  {
+    switch ( value )
+    {
+      case SamplerAddressMode::eRepeat : return "Repeat";
+      case SamplerAddressMode::eMirroredRepeat : return "MirroredRepeat";
+      case SamplerAddressMode::eClampToEdge : return "ClampToEdge";
+      case SamplerAddressMode::eClampToBorder : return "ClampToBorder";
+      case SamplerAddressMode::eMirrorClampToEdge : return "MirrorClampToEdge";
+      default: return "invalid";
+    }
+  }
+
+  enum class SamplerMipmapMode
+  {
+    eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST,
+    eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SamplerMipmapMode value )
+  {
+    switch ( value )
+    {
+      case SamplerMipmapMode::eNearest : return "Nearest";
+      case SamplerMipmapMode::eLinear : return "Linear";
+      default: return "invalid";
+    }
+  }
+
+  enum class SamplerReductionModeEXT
+  {
+    eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT,
+    eMin = VK_SAMPLER_REDUCTION_MODE_MIN_EXT,
+    eMax = VK_SAMPLER_REDUCTION_MODE_MAX_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SamplerReductionModeEXT value )
+  {
+    switch ( value )
+    {
+      case SamplerReductionModeEXT::eWeightedAverage : return "WeightedAverage";
+      case SamplerReductionModeEXT::eMin : return "Min";
+      case SamplerReductionModeEXT::eMax : return "Max";
+      default: return "invalid";
+    }
+  }
+
+  enum class SamplerYcbcrModelConversion
+  {
+    eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
+    eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
+    eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
+    eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
+    eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
+    eRgbIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR,
+    eYcbcrIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR,
+    eYcbcr709KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR,
+    eYcbcr601KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR,
+    eYcbcr2020KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SamplerYcbcrModelConversion value )
+  {
+    switch ( value )
+    {
+      case SamplerYcbcrModelConversion::eRgbIdentity : return "RgbIdentity";
+      case SamplerYcbcrModelConversion::eYcbcrIdentity : return "YcbcrIdentity";
+      case SamplerYcbcrModelConversion::eYcbcr709 : return "Ycbcr709";
+      case SamplerYcbcrModelConversion::eYcbcr601 : return "Ycbcr601";
+      case SamplerYcbcrModelConversion::eYcbcr2020 : return "Ycbcr2020";
+      default: return "invalid";
+    }
+  }
+
+  enum class SamplerYcbcrRange
+  {
+    eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
+    eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
+    eItuFullKHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR,
+    eItuNarrowKHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SamplerYcbcrRange value )
+  {
+    switch ( value )
+    {
+      case SamplerYcbcrRange::eItuFull : return "ItuFull";
+      case SamplerYcbcrRange::eItuNarrow : return "ItuNarrow";
+      default: return "invalid";
+    }
+  }
+
+  enum class ShaderInfoTypeAMD
+  {
+    eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
+    eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD,
+    eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ShaderInfoTypeAMD value )
+  {
+    switch ( value )
+    {
+      case ShaderInfoTypeAMD::eStatistics : return "Statistics";
+      case ShaderInfoTypeAMD::eBinary : return "Binary";
+      case ShaderInfoTypeAMD::eDisassembly : return "Disassembly";
+      default: return "invalid";
+    }
+  }
+
+  enum class ShadingRatePaletteEntryNV
+  {
+    eNoInvocations = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV,
+    e16InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV,
+    e8InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV,
+    e4InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV,
+    e2InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV,
+    e1InvocationPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV,
+    e1InvocationPer2X1Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV,
+    e1InvocationPer1X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV,
+    e1InvocationPer2X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV,
+    e1InvocationPer4X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV,
+    e1InvocationPer2X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV,
+    e1InvocationPer4X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ShadingRatePaletteEntryNV value )
+  {
+    switch ( value )
+    {
+      case ShadingRatePaletteEntryNV::eNoInvocations : return "NoInvocations";
+      case ShadingRatePaletteEntryNV::e16InvocationsPerPixel : return "16InvocationsPerPixel";
+      case ShadingRatePaletteEntryNV::e8InvocationsPerPixel : return "8InvocationsPerPixel";
+      case ShadingRatePaletteEntryNV::e4InvocationsPerPixel : return "4InvocationsPerPixel";
+      case ShadingRatePaletteEntryNV::e2InvocationsPerPixel : return "2InvocationsPerPixel";
+      case ShadingRatePaletteEntryNV::e1InvocationPerPixel : return "1InvocationPerPixel";
+      case ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels : return "1InvocationPer2X1Pixels";
+      case ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels : return "1InvocationPer1X2Pixels";
+      case ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels : return "1InvocationPer2X2Pixels";
+      case ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels : return "1InvocationPer4X2Pixels";
+      case ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels : return "1InvocationPer2X4Pixels";
+      case ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels : return "1InvocationPer4X4Pixels";
+      default: return "invalid";
+    }
+  }
+
+  enum class SharingMode
+  {
+    eExclusive = VK_SHARING_MODE_EXCLUSIVE,
+    eConcurrent = VK_SHARING_MODE_CONCURRENT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SharingMode value )
+  {
+    switch ( value )
+    {
+      case SharingMode::eExclusive : return "Exclusive";
+      case SharingMode::eConcurrent : return "Concurrent";
+      default: return "invalid";
+    }
+  }
+
+  enum class StencilOp
+  {
+    eKeep = VK_STENCIL_OP_KEEP,
+    eZero = VK_STENCIL_OP_ZERO,
+    eReplace = VK_STENCIL_OP_REPLACE,
+    eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP,
+    eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP,
+    eInvert = VK_STENCIL_OP_INVERT,
+    eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP,
+    eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( StencilOp value )
+  {
+    switch ( value )
+    {
+      case StencilOp::eKeep : return "Keep";
+      case StencilOp::eZero : return "Zero";
+      case StencilOp::eReplace : return "Replace";
+      case StencilOp::eIncrementAndClamp : return "IncrementAndClamp";
+      case StencilOp::eDecrementAndClamp : return "DecrementAndClamp";
+      case StencilOp::eInvert : return "Invert";
+      case StencilOp::eIncrementAndWrap : return "IncrementAndWrap";
+      case StencilOp::eDecrementAndWrap : return "DecrementAndWrap";
+      default: return "invalid";
+    }
+  }
 
   enum class StructureType
   {
@@ -9186,127 +4662,68 @@ public:
     eLoaderDeviceCreateInfo = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
     ePhysicalDeviceSubgroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES,
     eBindBufferMemoryInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
-    eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
     eBindImageMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
-    eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
     ePhysicalDevice16BitStorageFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
-    ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
     eMemoryDedicatedRequirements = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
-    eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
     eMemoryDedicatedAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
-    eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
     eMemoryAllocateFlagsInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
-    eMemoryAllocateFlagsInfoKHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
     eDeviceGroupRenderPassBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
-    eDeviceGroupRenderPassBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
     eDeviceGroupCommandBufferBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
-    eDeviceGroupCommandBufferBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
     eDeviceGroupSubmitInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
-    eDeviceGroupSubmitInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
     eDeviceGroupBindSparseInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
-    eDeviceGroupBindSparseInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
     eBindBufferMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
-    eBindBufferMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
     eBindImageMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
-    eBindImageMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
     ePhysicalDeviceGroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
-    ePhysicalDeviceGroupPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
     eDeviceGroupDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
-    eDeviceGroupDeviceCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
     eBufferMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
-    eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
     eImageMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
-    eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
     eImageSparseMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
-    eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
     eMemoryRequirements2 = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
-    eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
     eSparseImageMemoryRequirements2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
-    eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
     ePhysicalDeviceFeatures2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
-    ePhysicalDeviceFeatures2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
     ePhysicalDeviceProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
-    ePhysicalDeviceProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
     eFormatProperties2 = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
-    eFormatProperties2KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
     eImageFormatProperties2 = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
-    eImageFormatProperties2KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
     ePhysicalDeviceImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
-    ePhysicalDeviceImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
     eQueueFamilyProperties2 = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
-    eQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
     ePhysicalDeviceMemoryProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
-    ePhysicalDeviceMemoryProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
     eSparseImageFormatProperties2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
-    eSparseImageFormatProperties2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
     ePhysicalDeviceSparseImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
-    ePhysicalDeviceSparseImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
     ePhysicalDevicePointClippingProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
-    ePhysicalDevicePointClippingPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
     eRenderPassInputAttachmentAspectCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
-    eRenderPassInputAttachmentAspectCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
     eImageViewUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
-    eImageViewUsageCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
     ePipelineTessellationDomainOriginStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
-    ePipelineTessellationDomainOriginStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
     eRenderPassMultiviewCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
-    eRenderPassMultiviewCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
     ePhysicalDeviceMultiviewFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
-    ePhysicalDeviceMultiviewFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
     ePhysicalDeviceMultiviewProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
-    ePhysicalDeviceMultiviewPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
     ePhysicalDeviceVariablePointerFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
-    ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
     eProtectedSubmitInfo = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO,
     ePhysicalDeviceProtectedMemoryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
     ePhysicalDeviceProtectedMemoryProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES,
     eDeviceQueueInfo2 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
     eSamplerYcbcrConversionCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
-    eSamplerYcbcrConversionCreateInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
     eSamplerYcbcrConversionInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
-    eSamplerYcbcrConversionInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
     eBindImagePlaneMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
-    eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
     eImagePlaneMemoryRequirementsInfo = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
-    eImagePlaneMemoryRequirementsInfoKHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
     ePhysicalDeviceSamplerYcbcrConversionFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
-    ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
     eSamplerYcbcrConversionImageFormatProperties = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
-    eSamplerYcbcrConversionImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
     eDescriptorUpdateTemplateCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
-    eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
     ePhysicalDeviceExternalImageFormatInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
-    ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
     eExternalImageFormatProperties = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
-    eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
     ePhysicalDeviceExternalBufferInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
-    ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
     eExternalBufferProperties = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
-    eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
     ePhysicalDeviceIdProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
-    ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
     eExternalMemoryBufferCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
-    eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
     eExternalMemoryImageCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
-    eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
     eExportMemoryAllocateInfo = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
-    eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
     ePhysicalDeviceExternalFenceInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
-    ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
     eExternalFenceProperties = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
-    eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
     eExportFenceCreateInfo = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
-    eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
     eExportSemaphoreCreateInfo = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
-    eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
     ePhysicalDeviceExternalSemaphoreInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
-    ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
     eExternalSemaphoreProperties = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
-    eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
     ePhysicalDeviceMaintenance3Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
-    ePhysicalDeviceMaintenance3PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
     eDescriptorSetLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
-    eDescriptorSetLayoutSupportKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
     ePhysicalDeviceShaderDrawParameterFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES,
     eSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
     ePresentInfoKHR = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
@@ -9325,7 +4742,6 @@ public:
     eAndroidSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR,
     eWin32SurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
     eDebugReportCallbackCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
-    eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
     ePipelineRasterizationStateRasterizationOrderAMD = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD,
     eDebugMarkerObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT,
     eDebugMarkerObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT,
@@ -9496,9 +4912,11819 @@ public:
     ePhysicalDeviceFragmentDensityMapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT,
     eRenderPassFragmentDensityMapCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,
     ePhysicalDeviceScalarBlockLayoutFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT,
-    eImageStencilUsageCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT
+    eImageStencilUsageCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT,
+    eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT,
+    eRenderPassMultiviewCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR,
+    ePhysicalDeviceMultiviewFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR,
+    ePhysicalDeviceMultiviewPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR,
+    ePhysicalDeviceFeatures2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR,
+    ePhysicalDeviceProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,
+    eFormatProperties2KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR,
+    eImageFormatProperties2KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR,
+    ePhysicalDeviceImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
+    eQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR,
+    ePhysicalDeviceMemoryProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR,
+    eSparseImageFormatProperties2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR,
+    ePhysicalDeviceSparseImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR,
+    eMemoryAllocateFlagsInfoKHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR,
+    eDeviceGroupRenderPassBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR,
+    eDeviceGroupCommandBufferBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR,
+    eDeviceGroupSubmitInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR,
+    eDeviceGroupBindSparseInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR,
+    eBindBufferMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR,
+    eBindImageMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR,
+    ePhysicalDeviceGroupPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR,
+    eDeviceGroupDeviceCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR,
+    ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR,
+    eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
+    ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR,
+    eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR,
+    ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR,
+    eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR,
+    eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR,
+    eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR,
+    ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR,
+    eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR,
+    eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR,
+    ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR,
+    eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
+    ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR,
+    eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR,
+    eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR,
+    ePhysicalDevicePointClippingPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR,
+    eRenderPassInputAttachmentAspectCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR,
+    eImageViewUsageCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR,
+    ePipelineTessellationDomainOriginStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR,
+    ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR,
+    eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
+    eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
+    eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR,
+    eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR,
+    eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR,
+    eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
+    eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR,
+    eSamplerYcbcrConversionCreateInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR,
+    eSamplerYcbcrConversionInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR,
+    eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR,
+    eImagePlaneMemoryRequirementsInfoKHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR,
+    ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR,
+    eSamplerYcbcrConversionImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR,
+    eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR,
+    eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR,
+    ePhysicalDeviceMaintenance3PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR,
+    eDescriptorSetLayoutSupportKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR
   };
 
+  VULKAN_HPP_INLINE std::string to_string( StructureType value )
+  {
+    switch ( value )
+    {
+      case StructureType::eApplicationInfo : return "ApplicationInfo";
+      case StructureType::eInstanceCreateInfo : return "InstanceCreateInfo";
+      case StructureType::eDeviceQueueCreateInfo : return "DeviceQueueCreateInfo";
+      case StructureType::eDeviceCreateInfo : return "DeviceCreateInfo";
+      case StructureType::eSubmitInfo : return "SubmitInfo";
+      case StructureType::eMemoryAllocateInfo : return "MemoryAllocateInfo";
+      case StructureType::eMappedMemoryRange : return "MappedMemoryRange";
+      case StructureType::eBindSparseInfo : return "BindSparseInfo";
+      case StructureType::eFenceCreateInfo : return "FenceCreateInfo";
+      case StructureType::eSemaphoreCreateInfo : return "SemaphoreCreateInfo";
+      case StructureType::eEventCreateInfo : return "EventCreateInfo";
+      case StructureType::eQueryPoolCreateInfo : return "QueryPoolCreateInfo";
+      case StructureType::eBufferCreateInfo : return "BufferCreateInfo";
+      case StructureType::eBufferViewCreateInfo : return "BufferViewCreateInfo";
+      case StructureType::eImageCreateInfo : return "ImageCreateInfo";
+      case StructureType::eImageViewCreateInfo : return "ImageViewCreateInfo";
+      case StructureType::eShaderModuleCreateInfo : return "ShaderModuleCreateInfo";
+      case StructureType::ePipelineCacheCreateInfo : return "PipelineCacheCreateInfo";
+      case StructureType::ePipelineShaderStageCreateInfo : return "PipelineShaderStageCreateInfo";
+      case StructureType::ePipelineVertexInputStateCreateInfo : return "PipelineVertexInputStateCreateInfo";
+      case StructureType::ePipelineInputAssemblyStateCreateInfo : return "PipelineInputAssemblyStateCreateInfo";
+      case StructureType::ePipelineTessellationStateCreateInfo : return "PipelineTessellationStateCreateInfo";
+      case StructureType::ePipelineViewportStateCreateInfo : return "PipelineViewportStateCreateInfo";
+      case StructureType::ePipelineRasterizationStateCreateInfo : return "PipelineRasterizationStateCreateInfo";
+      case StructureType::ePipelineMultisampleStateCreateInfo : return "PipelineMultisampleStateCreateInfo";
+      case StructureType::ePipelineDepthStencilStateCreateInfo : return "PipelineDepthStencilStateCreateInfo";
+      case StructureType::ePipelineColorBlendStateCreateInfo : return "PipelineColorBlendStateCreateInfo";
+      case StructureType::ePipelineDynamicStateCreateInfo : return "PipelineDynamicStateCreateInfo";
+      case StructureType::eGraphicsPipelineCreateInfo : return "GraphicsPipelineCreateInfo";
+      case StructureType::eComputePipelineCreateInfo : return "ComputePipelineCreateInfo";
+      case StructureType::ePipelineLayoutCreateInfo : return "PipelineLayoutCreateInfo";
+      case StructureType::eSamplerCreateInfo : return "SamplerCreateInfo";
+      case StructureType::eDescriptorSetLayoutCreateInfo : return "DescriptorSetLayoutCreateInfo";
+      case StructureType::eDescriptorPoolCreateInfo : return "DescriptorPoolCreateInfo";
+      case StructureType::eDescriptorSetAllocateInfo : return "DescriptorSetAllocateInfo";
+      case StructureType::eWriteDescriptorSet : return "WriteDescriptorSet";
+      case StructureType::eCopyDescriptorSet : return "CopyDescriptorSet";
+      case StructureType::eFramebufferCreateInfo : return "FramebufferCreateInfo";
+      case StructureType::eRenderPassCreateInfo : return "RenderPassCreateInfo";
+      case StructureType::eCommandPoolCreateInfo : return "CommandPoolCreateInfo";
+      case StructureType::eCommandBufferAllocateInfo : return "CommandBufferAllocateInfo";
+      case StructureType::eCommandBufferInheritanceInfo : return "CommandBufferInheritanceInfo";
+      case StructureType::eCommandBufferBeginInfo : return "CommandBufferBeginInfo";
+      case StructureType::eRenderPassBeginInfo : return "RenderPassBeginInfo";
+      case StructureType::eBufferMemoryBarrier : return "BufferMemoryBarrier";
+      case StructureType::eImageMemoryBarrier : return "ImageMemoryBarrier";
+      case StructureType::eMemoryBarrier : return "MemoryBarrier";
+      case StructureType::eLoaderInstanceCreateInfo : return "LoaderInstanceCreateInfo";
+      case StructureType::eLoaderDeviceCreateInfo : return "LoaderDeviceCreateInfo";
+      case StructureType::ePhysicalDeviceSubgroupProperties : return "PhysicalDeviceSubgroupProperties";
+      case StructureType::eBindBufferMemoryInfo : return "BindBufferMemoryInfo";
+      case StructureType::eBindImageMemoryInfo : return "BindImageMemoryInfo";
+      case StructureType::ePhysicalDevice16BitStorageFeatures : return "PhysicalDevice16BitStorageFeatures";
+      case StructureType::eMemoryDedicatedRequirements : return "MemoryDedicatedRequirements";
+      case StructureType::eMemoryDedicatedAllocateInfo : return "MemoryDedicatedAllocateInfo";
+      case StructureType::eMemoryAllocateFlagsInfo : return "MemoryAllocateFlagsInfo";
+      case StructureType::eDeviceGroupRenderPassBeginInfo : return "DeviceGroupRenderPassBeginInfo";
+      case StructureType::eDeviceGroupCommandBufferBeginInfo : return "DeviceGroupCommandBufferBeginInfo";
+      case StructureType::eDeviceGroupSubmitInfo : return "DeviceGroupSubmitInfo";
+      case StructureType::eDeviceGroupBindSparseInfo : return "DeviceGroupBindSparseInfo";
+      case StructureType::eBindBufferMemoryDeviceGroupInfo : return "BindBufferMemoryDeviceGroupInfo";
+      case StructureType::eBindImageMemoryDeviceGroupInfo : return "BindImageMemoryDeviceGroupInfo";
+      case StructureType::ePhysicalDeviceGroupProperties : return "PhysicalDeviceGroupProperties";
+      case StructureType::eDeviceGroupDeviceCreateInfo : return "DeviceGroupDeviceCreateInfo";
+      case StructureType::eBufferMemoryRequirementsInfo2 : return "BufferMemoryRequirementsInfo2";
+      case StructureType::eImageMemoryRequirementsInfo2 : return "ImageMemoryRequirementsInfo2";
+      case StructureType::eImageSparseMemoryRequirementsInfo2 : return "ImageSparseMemoryRequirementsInfo2";
+      case StructureType::eMemoryRequirements2 : return "MemoryRequirements2";
+      case StructureType::eSparseImageMemoryRequirements2 : return "SparseImageMemoryRequirements2";
+      case StructureType::ePhysicalDeviceFeatures2 : return "PhysicalDeviceFeatures2";
+      case StructureType::ePhysicalDeviceProperties2 : return "PhysicalDeviceProperties2";
+      case StructureType::eFormatProperties2 : return "FormatProperties2";
+      case StructureType::eImageFormatProperties2 : return "ImageFormatProperties2";
+      case StructureType::ePhysicalDeviceImageFormatInfo2 : return "PhysicalDeviceImageFormatInfo2";
+      case StructureType::eQueueFamilyProperties2 : return "QueueFamilyProperties2";
+      case StructureType::ePhysicalDeviceMemoryProperties2 : return "PhysicalDeviceMemoryProperties2";
+      case StructureType::eSparseImageFormatProperties2 : return "SparseImageFormatProperties2";
+      case StructureType::ePhysicalDeviceSparseImageFormatInfo2 : return "PhysicalDeviceSparseImageFormatInfo2";
+      case StructureType::ePhysicalDevicePointClippingProperties : return "PhysicalDevicePointClippingProperties";
+      case StructureType::eRenderPassInputAttachmentAspectCreateInfo : return "RenderPassInputAttachmentAspectCreateInfo";
+      case StructureType::eImageViewUsageCreateInfo : return "ImageViewUsageCreateInfo";
+      case StructureType::ePipelineTessellationDomainOriginStateCreateInfo : return "PipelineTessellationDomainOriginStateCreateInfo";
+      case StructureType::eRenderPassMultiviewCreateInfo : return "RenderPassMultiviewCreateInfo";
+      case StructureType::ePhysicalDeviceMultiviewFeatures : return "PhysicalDeviceMultiviewFeatures";
+      case StructureType::ePhysicalDeviceMultiviewProperties : return "PhysicalDeviceMultiviewProperties";
+      case StructureType::ePhysicalDeviceVariablePointerFeatures : return "PhysicalDeviceVariablePointerFeatures";
+      case StructureType::eProtectedSubmitInfo : return "ProtectedSubmitInfo";
+      case StructureType::ePhysicalDeviceProtectedMemoryFeatures : return "PhysicalDeviceProtectedMemoryFeatures";
+      case StructureType::ePhysicalDeviceProtectedMemoryProperties : return "PhysicalDeviceProtectedMemoryProperties";
+      case StructureType::eDeviceQueueInfo2 : return "DeviceQueueInfo2";
+      case StructureType::eSamplerYcbcrConversionCreateInfo : return "SamplerYcbcrConversionCreateInfo";
+      case StructureType::eSamplerYcbcrConversionInfo : return "SamplerYcbcrConversionInfo";
+      case StructureType::eBindImagePlaneMemoryInfo : return "BindImagePlaneMemoryInfo";
+      case StructureType::eImagePlaneMemoryRequirementsInfo : return "ImagePlaneMemoryRequirementsInfo";
+      case StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures : return "PhysicalDeviceSamplerYcbcrConversionFeatures";
+      case StructureType::eSamplerYcbcrConversionImageFormatProperties : return "SamplerYcbcrConversionImageFormatProperties";
+      case StructureType::eDescriptorUpdateTemplateCreateInfo : return "DescriptorUpdateTemplateCreateInfo";
+      case StructureType::ePhysicalDeviceExternalImageFormatInfo : return "PhysicalDeviceExternalImageFormatInfo";
+      case StructureType::eExternalImageFormatProperties : return "ExternalImageFormatProperties";
+      case StructureType::ePhysicalDeviceExternalBufferInfo : return "PhysicalDeviceExternalBufferInfo";
+      case StructureType::eExternalBufferProperties : return "ExternalBufferProperties";
+      case StructureType::ePhysicalDeviceIdProperties : return "PhysicalDeviceIdProperties";
+      case StructureType::eExternalMemoryBufferCreateInfo : return "ExternalMemoryBufferCreateInfo";
+      case StructureType::eExternalMemoryImageCreateInfo : return "ExternalMemoryImageCreateInfo";
+      case StructureType::eExportMemoryAllocateInfo : return "ExportMemoryAllocateInfo";
+      case StructureType::ePhysicalDeviceExternalFenceInfo : return "PhysicalDeviceExternalFenceInfo";
+      case StructureType::eExternalFenceProperties : return "ExternalFenceProperties";
+      case StructureType::eExportFenceCreateInfo : return "ExportFenceCreateInfo";
+      case StructureType::eExportSemaphoreCreateInfo : return "ExportSemaphoreCreateInfo";
+      case StructureType::ePhysicalDeviceExternalSemaphoreInfo : return "PhysicalDeviceExternalSemaphoreInfo";
+      case StructureType::eExternalSemaphoreProperties : return "ExternalSemaphoreProperties";
+      case StructureType::ePhysicalDeviceMaintenance3Properties : return "PhysicalDeviceMaintenance3Properties";
+      case StructureType::eDescriptorSetLayoutSupport : return "DescriptorSetLayoutSupport";
+      case StructureType::ePhysicalDeviceShaderDrawParameterFeatures : return "PhysicalDeviceShaderDrawParameterFeatures";
+      case StructureType::eSwapchainCreateInfoKHR : return "SwapchainCreateInfoKHR";
+      case StructureType::ePresentInfoKHR : return "PresentInfoKHR";
+      case StructureType::eDeviceGroupPresentCapabilitiesKHR : return "DeviceGroupPresentCapabilitiesKHR";
+      case StructureType::eImageSwapchainCreateInfoKHR : return "ImageSwapchainCreateInfoKHR";
+      case StructureType::eBindImageMemorySwapchainInfoKHR : return "BindImageMemorySwapchainInfoKHR";
+      case StructureType::eAcquireNextImageInfoKHR : return "AcquireNextImageInfoKHR";
+      case StructureType::eDeviceGroupPresentInfoKHR : return "DeviceGroupPresentInfoKHR";
+      case StructureType::eDeviceGroupSwapchainCreateInfoKHR : return "DeviceGroupSwapchainCreateInfoKHR";
+      case StructureType::eDisplayModeCreateInfoKHR : return "DisplayModeCreateInfoKHR";
+      case StructureType::eDisplaySurfaceCreateInfoKHR : return "DisplaySurfaceCreateInfoKHR";
+      case StructureType::eDisplayPresentInfoKHR : return "DisplayPresentInfoKHR";
+      case StructureType::eXlibSurfaceCreateInfoKHR : return "XlibSurfaceCreateInfoKHR";
+      case StructureType::eXcbSurfaceCreateInfoKHR : return "XcbSurfaceCreateInfoKHR";
+      case StructureType::eWaylandSurfaceCreateInfoKHR : return "WaylandSurfaceCreateInfoKHR";
+      case StructureType::eAndroidSurfaceCreateInfoKHR : return "AndroidSurfaceCreateInfoKHR";
+      case StructureType::eWin32SurfaceCreateInfoKHR : return "Win32SurfaceCreateInfoKHR";
+      case StructureType::eDebugReportCallbackCreateInfoEXT : return "DebugReportCallbackCreateInfoEXT";
+      case StructureType::ePipelineRasterizationStateRasterizationOrderAMD : return "PipelineRasterizationStateRasterizationOrderAMD";
+      case StructureType::eDebugMarkerObjectNameInfoEXT : return "DebugMarkerObjectNameInfoEXT";
+      case StructureType::eDebugMarkerObjectTagInfoEXT : return "DebugMarkerObjectTagInfoEXT";
+      case StructureType::eDebugMarkerMarkerInfoEXT : return "DebugMarkerMarkerInfoEXT";
+      case StructureType::eDedicatedAllocationImageCreateInfoNV : return "DedicatedAllocationImageCreateInfoNV";
+      case StructureType::eDedicatedAllocationBufferCreateInfoNV : return "DedicatedAllocationBufferCreateInfoNV";
+      case StructureType::eDedicatedAllocationMemoryAllocateInfoNV : return "DedicatedAllocationMemoryAllocateInfoNV";
+      case StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT : return "PhysicalDeviceTransformFeedbackFeaturesEXT";
+      case StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT : return "PhysicalDeviceTransformFeedbackPropertiesEXT";
+      case StructureType::ePipelineRasterizationStateStreamCreateInfoEXT : return "PipelineRasterizationStateStreamCreateInfoEXT";
+      case StructureType::eTextureLodGatherFormatPropertiesAMD : return "TextureLodGatherFormatPropertiesAMD";
+      case StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV : return "PhysicalDeviceCornerSampledImageFeaturesNV";
+      case StructureType::eExternalMemoryImageCreateInfoNV : return "ExternalMemoryImageCreateInfoNV";
+      case StructureType::eExportMemoryAllocateInfoNV : return "ExportMemoryAllocateInfoNV";
+      case StructureType::eImportMemoryWin32HandleInfoNV : return "ImportMemoryWin32HandleInfoNV";
+      case StructureType::eExportMemoryWin32HandleInfoNV : return "ExportMemoryWin32HandleInfoNV";
+      case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV : return "Win32KeyedMutexAcquireReleaseInfoNV";
+      case StructureType::eValidationFlagsEXT : return "ValidationFlagsEXT";
+      case StructureType::eViSurfaceCreateInfoNN : return "ViSurfaceCreateInfoNN";
+      case StructureType::eImageViewAstcDecodeModeEXT : return "ImageViewAstcDecodeModeEXT";
+      case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT : return "PhysicalDeviceAstcDecodeFeaturesEXT";
+      case StructureType::eImportMemoryWin32HandleInfoKHR : return "ImportMemoryWin32HandleInfoKHR";
+      case StructureType::eExportMemoryWin32HandleInfoKHR : return "ExportMemoryWin32HandleInfoKHR";
+      case StructureType::eMemoryWin32HandlePropertiesKHR : return "MemoryWin32HandlePropertiesKHR";
+      case StructureType::eMemoryGetWin32HandleInfoKHR : return "MemoryGetWin32HandleInfoKHR";
+      case StructureType::eImportMemoryFdInfoKHR : return "ImportMemoryFdInfoKHR";
+      case StructureType::eMemoryFdPropertiesKHR : return "MemoryFdPropertiesKHR";
+      case StructureType::eMemoryGetFdInfoKHR : return "MemoryGetFdInfoKHR";
+      case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR : return "Win32KeyedMutexAcquireReleaseInfoKHR";
+      case StructureType::eImportSemaphoreWin32HandleInfoKHR : return "ImportSemaphoreWin32HandleInfoKHR";
+      case StructureType::eExportSemaphoreWin32HandleInfoKHR : return "ExportSemaphoreWin32HandleInfoKHR";
+      case StructureType::eD3D12FenceSubmitInfoKHR : return "D3D12FenceSubmitInfoKHR";
+      case StructureType::eSemaphoreGetWin32HandleInfoKHR : return "SemaphoreGetWin32HandleInfoKHR";
+      case StructureType::eImportSemaphoreFdInfoKHR : return "ImportSemaphoreFdInfoKHR";
+      case StructureType::eSemaphoreGetFdInfoKHR : return "SemaphoreGetFdInfoKHR";
+      case StructureType::ePhysicalDevicePushDescriptorPropertiesKHR : return "PhysicalDevicePushDescriptorPropertiesKHR";
+      case StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT : return "CommandBufferInheritanceConditionalRenderingInfoEXT";
+      case StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT : return "PhysicalDeviceConditionalRenderingFeaturesEXT";
+      case StructureType::eConditionalRenderingBeginInfoEXT : return "ConditionalRenderingBeginInfoEXT";
+      case StructureType::ePresentRegionsKHR : return "PresentRegionsKHR";
+      case StructureType::eObjectTableCreateInfoNVX : return "ObjectTableCreateInfoNVX";
+      case StructureType::eIndirectCommandsLayoutCreateInfoNVX : return "IndirectCommandsLayoutCreateInfoNVX";
+      case StructureType::eCmdProcessCommandsInfoNVX : return "CmdProcessCommandsInfoNVX";
+      case StructureType::eCmdReserveSpaceForCommandsInfoNVX : return "CmdReserveSpaceForCommandsInfoNVX";
+      case StructureType::eDeviceGeneratedCommandsLimitsNVX : return "DeviceGeneratedCommandsLimitsNVX";
+      case StructureType::eDeviceGeneratedCommandsFeaturesNVX : return "DeviceGeneratedCommandsFeaturesNVX";
+      case StructureType::ePipelineViewportWScalingStateCreateInfoNV : return "PipelineViewportWScalingStateCreateInfoNV";
+      case StructureType::eSurfaceCapabilities2EXT : return "SurfaceCapabilities2EXT";
+      case StructureType::eDisplayPowerInfoEXT : return "DisplayPowerInfoEXT";
+      case StructureType::eDeviceEventInfoEXT : return "DeviceEventInfoEXT";
+      case StructureType::eDisplayEventInfoEXT : return "DisplayEventInfoEXT";
+      case StructureType::eSwapchainCounterCreateInfoEXT : return "SwapchainCounterCreateInfoEXT";
+      case StructureType::ePresentTimesInfoGOOGLE : return "PresentTimesInfoGOOGLE";
+      case StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX : return "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX";
+      case StructureType::ePipelineViewportSwizzleStateCreateInfoNV : return "PipelineViewportSwizzleStateCreateInfoNV";
+      case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT : return "PhysicalDeviceDiscardRectanglePropertiesEXT";
+      case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT : return "PipelineDiscardRectangleStateCreateInfoEXT";
+      case StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT : return "PhysicalDeviceConservativeRasterizationPropertiesEXT";
+      case StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT : return "PipelineRasterizationConservativeStateCreateInfoEXT";
+      case StructureType::eHdrMetadataEXT : return "HdrMetadataEXT";
+      case StructureType::eAttachmentDescription2KHR : return "AttachmentDescription2KHR";
+      case StructureType::eAttachmentReference2KHR : return "AttachmentReference2KHR";
+      case StructureType::eSubpassDescription2KHR : return "SubpassDescription2KHR";
+      case StructureType::eSubpassDependency2KHR : return "SubpassDependency2KHR";
+      case StructureType::eRenderPassCreateInfo2KHR : return "RenderPassCreateInfo2KHR";
+      case StructureType::eSubpassBeginInfoKHR : return "SubpassBeginInfoKHR";
+      case StructureType::eSubpassEndInfoKHR : return "SubpassEndInfoKHR";
+      case StructureType::eSharedPresentSurfaceCapabilitiesKHR : return "SharedPresentSurfaceCapabilitiesKHR";
+      case StructureType::eImportFenceWin32HandleInfoKHR : return "ImportFenceWin32HandleInfoKHR";
+      case StructureType::eExportFenceWin32HandleInfoKHR : return "ExportFenceWin32HandleInfoKHR";
+      case StructureType::eFenceGetWin32HandleInfoKHR : return "FenceGetWin32HandleInfoKHR";
+      case StructureType::eImportFenceFdInfoKHR : return "ImportFenceFdInfoKHR";
+      case StructureType::eFenceGetFdInfoKHR : return "FenceGetFdInfoKHR";
+      case StructureType::ePhysicalDeviceSurfaceInfo2KHR : return "PhysicalDeviceSurfaceInfo2KHR";
+      case StructureType::eSurfaceCapabilities2KHR : return "SurfaceCapabilities2KHR";
+      case StructureType::eSurfaceFormat2KHR : return "SurfaceFormat2KHR";
+      case StructureType::eDisplayProperties2KHR : return "DisplayProperties2KHR";
+      case StructureType::eDisplayPlaneProperties2KHR : return "DisplayPlaneProperties2KHR";
+      case StructureType::eDisplayModeProperties2KHR : return "DisplayModeProperties2KHR";
+      case StructureType::eDisplayPlaneInfo2KHR : return "DisplayPlaneInfo2KHR";
+      case StructureType::eDisplayPlaneCapabilities2KHR : return "DisplayPlaneCapabilities2KHR";
+      case StructureType::eIosSurfaceCreateInfoMVK : return "IosSurfaceCreateInfoMVK";
+      case StructureType::eMacosSurfaceCreateInfoMVK : return "MacosSurfaceCreateInfoMVK";
+      case StructureType::eDebugUtilsObjectNameInfoEXT : return "DebugUtilsObjectNameInfoEXT";
+      case StructureType::eDebugUtilsObjectTagInfoEXT : return "DebugUtilsObjectTagInfoEXT";
+      case StructureType::eDebugUtilsLabelEXT : return "DebugUtilsLabelEXT";
+      case StructureType::eDebugUtilsMessengerCallbackDataEXT : return "DebugUtilsMessengerCallbackDataEXT";
+      case StructureType::eDebugUtilsMessengerCreateInfoEXT : return "DebugUtilsMessengerCreateInfoEXT";
+      case StructureType::eAndroidHardwareBufferUsageANDROID : return "AndroidHardwareBufferUsageANDROID";
+      case StructureType::eAndroidHardwareBufferPropertiesANDROID : return "AndroidHardwareBufferPropertiesANDROID";
+      case StructureType::eAndroidHardwareBufferFormatPropertiesANDROID : return "AndroidHardwareBufferFormatPropertiesANDROID";
+      case StructureType::eImportAndroidHardwareBufferInfoANDROID : return "ImportAndroidHardwareBufferInfoANDROID";
+      case StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID : return "MemoryGetAndroidHardwareBufferInfoANDROID";
+      case StructureType::eExternalFormatANDROID : return "ExternalFormatANDROID";
+      case StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT : return "PhysicalDeviceSamplerFilterMinmaxPropertiesEXT";
+      case StructureType::eSamplerReductionModeCreateInfoEXT : return "SamplerReductionModeCreateInfoEXT";
+      case StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT : return "PhysicalDeviceInlineUniformBlockFeaturesEXT";
+      case StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT : return "PhysicalDeviceInlineUniformBlockPropertiesEXT";
+      case StructureType::eWriteDescriptorSetInlineUniformBlockEXT : return "WriteDescriptorSetInlineUniformBlockEXT";
+      case StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT : return "DescriptorPoolInlineUniformBlockCreateInfoEXT";
+      case StructureType::eSampleLocationsInfoEXT : return "SampleLocationsInfoEXT";
+      case StructureType::eRenderPassSampleLocationsBeginInfoEXT : return "RenderPassSampleLocationsBeginInfoEXT";
+      case StructureType::ePipelineSampleLocationsStateCreateInfoEXT : return "PipelineSampleLocationsStateCreateInfoEXT";
+      case StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT : return "PhysicalDeviceSampleLocationsPropertiesEXT";
+      case StructureType::eMultisamplePropertiesEXT : return "MultisamplePropertiesEXT";
+      case StructureType::eImageFormatListCreateInfoKHR : return "ImageFormatListCreateInfoKHR";
+      case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT : return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT";
+      case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT : return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT";
+      case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT : return "PipelineColorBlendAdvancedStateCreateInfoEXT";
+      case StructureType::ePipelineCoverageToColorStateCreateInfoNV : return "PipelineCoverageToColorStateCreateInfoNV";
+      case StructureType::ePipelineCoverageModulationStateCreateInfoNV : return "PipelineCoverageModulationStateCreateInfoNV";
+      case StructureType::eDrmFormatModifierPropertiesListEXT : return "DrmFormatModifierPropertiesListEXT";
+      case StructureType::eDrmFormatModifierPropertiesEXT : return "DrmFormatModifierPropertiesEXT";
+      case StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT : return "PhysicalDeviceImageDrmFormatModifierInfoEXT";
+      case StructureType::eImageDrmFormatModifierListCreateInfoEXT : return "ImageDrmFormatModifierListCreateInfoEXT";
+      case StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT : return "ImageDrmFormatModifierExplicitCreateInfoEXT";
+      case StructureType::eImageDrmFormatModifierPropertiesEXT : return "ImageDrmFormatModifierPropertiesEXT";
+      case StructureType::eValidationCacheCreateInfoEXT : return "ValidationCacheCreateInfoEXT";
+      case StructureType::eShaderModuleValidationCacheCreateInfoEXT : return "ShaderModuleValidationCacheCreateInfoEXT";
+      case StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT : return "DescriptorSetLayoutBindingFlagsCreateInfoEXT";
+      case StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT : return "PhysicalDeviceDescriptorIndexingFeaturesEXT";
+      case StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT : return "PhysicalDeviceDescriptorIndexingPropertiesEXT";
+      case StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT : return "DescriptorSetVariableDescriptorCountAllocateInfoEXT";
+      case StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT : return "DescriptorSetVariableDescriptorCountLayoutSupportEXT";
+      case StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV : return "PipelineViewportShadingRateImageStateCreateInfoNV";
+      case StructureType::ePhysicalDeviceShadingRateImageFeaturesNV : return "PhysicalDeviceShadingRateImageFeaturesNV";
+      case StructureType::ePhysicalDeviceShadingRateImagePropertiesNV : return "PhysicalDeviceShadingRateImagePropertiesNV";
+      case StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV : return "PipelineViewportCoarseSampleOrderStateCreateInfoNV";
+      case StructureType::eRayTracingPipelineCreateInfoNV : return "RayTracingPipelineCreateInfoNV";
+      case StructureType::eAccelerationStructureCreateInfoNV : return "AccelerationStructureCreateInfoNV";
+      case StructureType::eGeometryNV : return "GeometryNV";
+      case StructureType::eGeometryTrianglesNV : return "GeometryTrianglesNV";
+      case StructureType::eGeometryAabbNV : return "GeometryAabbNV";
+      case StructureType::eBindAccelerationStructureMemoryInfoNV : return "BindAccelerationStructureMemoryInfoNV";
+      case StructureType::eWriteDescriptorSetAccelerationStructureNV : return "WriteDescriptorSetAccelerationStructureNV";
+      case StructureType::eAccelerationStructureMemoryRequirementsInfoNV : return "AccelerationStructureMemoryRequirementsInfoNV";
+      case StructureType::ePhysicalDeviceRayTracingPropertiesNV : return "PhysicalDeviceRayTracingPropertiesNV";
+      case StructureType::eRayTracingShaderGroupCreateInfoNV : return "RayTracingShaderGroupCreateInfoNV";
+      case StructureType::eAccelerationStructureInfoNV : return "AccelerationStructureInfoNV";
+      case StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV : return "PhysicalDeviceRepresentativeFragmentTestFeaturesNV";
+      case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV : return "PipelineRepresentativeFragmentTestStateCreateInfoNV";
+      case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT : return "DeviceQueueGlobalPriorityCreateInfoEXT";
+      case StructureType::ePhysicalDevice8BitStorageFeaturesKHR : return "PhysicalDevice8BitStorageFeaturesKHR";
+      case StructureType::eImportMemoryHostPointerInfoEXT : return "ImportMemoryHostPointerInfoEXT";
+      case StructureType::eMemoryHostPointerPropertiesEXT : return "MemoryHostPointerPropertiesEXT";
+      case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT : return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
+      case StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR : return "PhysicalDeviceShaderAtomicInt64FeaturesKHR";
+      case StructureType::eCalibratedTimestampInfoEXT : return "CalibratedTimestampInfoEXT";
+      case StructureType::ePhysicalDeviceShaderCorePropertiesAMD : return "PhysicalDeviceShaderCorePropertiesAMD";
+      case StructureType::eDeviceMemoryOverallocationCreateInfoAMD : return "DeviceMemoryOverallocationCreateInfoAMD";
+      case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT : return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT";
+      case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT : return "PipelineVertexInputDivisorStateCreateInfoEXT";
+      case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT : return "PhysicalDeviceVertexAttributeDivisorFeaturesEXT";
+      case StructureType::ePhysicalDeviceDriverPropertiesKHR : return "PhysicalDeviceDriverPropertiesKHR";
+      case StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV : return "PhysicalDeviceComputeShaderDerivativesFeaturesNV";
+      case StructureType::ePhysicalDeviceMeshShaderFeaturesNV : return "PhysicalDeviceMeshShaderFeaturesNV";
+      case StructureType::ePhysicalDeviceMeshShaderPropertiesNV : return "PhysicalDeviceMeshShaderPropertiesNV";
+      case StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV : return "PhysicalDeviceFragmentShaderBarycentricFeaturesNV";
+      case StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV : return "PhysicalDeviceShaderImageFootprintFeaturesNV";
+      case StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV : return "PipelineViewportExclusiveScissorStateCreateInfoNV";
+      case StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV : return "PhysicalDeviceExclusiveScissorFeaturesNV";
+      case StructureType::eCheckpointDataNV : return "CheckpointDataNV";
+      case StructureType::eQueueFamilyCheckpointPropertiesNV : return "QueueFamilyCheckpointPropertiesNV";
+      case StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR : return "PhysicalDeviceVulkanMemoryModelFeaturesKHR";
+      case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT : return "PhysicalDevicePciBusInfoPropertiesEXT";
+      case StructureType::eImagepipeSurfaceCreateInfoFUCHSIA : return "ImagepipeSurfaceCreateInfoFUCHSIA";
+      case StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT : return "PhysicalDeviceFragmentDensityMapFeaturesEXT";
+      case StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT : return "PhysicalDeviceFragmentDensityMapPropertiesEXT";
+      case StructureType::eRenderPassFragmentDensityMapCreateInfoEXT : return "RenderPassFragmentDensityMapCreateInfoEXT";
+      case StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT : return "PhysicalDeviceScalarBlockLayoutFeaturesEXT";
+      case StructureType::eImageStencilUsageCreateInfoEXT : return "ImageStencilUsageCreateInfoEXT";
+      default: return "invalid";
+    }
+  }
+
+  enum class SubpassContents
+  {
+    eInline = VK_SUBPASS_CONTENTS_INLINE,
+    eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SubpassContents value )
+  {
+    switch ( value )
+    {
+      case SubpassContents::eInline : return "Inline";
+      case SubpassContents::eSecondaryCommandBuffers : return "SecondaryCommandBuffers";
+      default: return "invalid";
+    }
+  }
+
+  enum class SystemAllocationScope
+  {
+    eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
+    eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT,
+    eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE,
+    eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE,
+    eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SystemAllocationScope value )
+  {
+    switch ( value )
+    {
+      case SystemAllocationScope::eCommand : return "Command";
+      case SystemAllocationScope::eObject : return "Object";
+      case SystemAllocationScope::eCache : return "Cache";
+      case SystemAllocationScope::eDevice : return "Device";
+      case SystemAllocationScope::eInstance : return "Instance";
+      default: return "invalid";
+    }
+  }
+
+  enum class TessellationDomainOrigin
+  {
+    eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
+    eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
+    eUpperLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR,
+    eLowerLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( TessellationDomainOrigin value )
+  {
+    switch ( value )
+    {
+      case TessellationDomainOrigin::eUpperLeft : return "UpperLeft";
+      case TessellationDomainOrigin::eLowerLeft : return "LowerLeft";
+      default: return "invalid";
+    }
+  }
+
+  enum class TimeDomainEXT
+  {
+    eDevice = VK_TIME_DOMAIN_DEVICE_EXT,
+    eClockMonotonic = VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT,
+    eClockMonotonicRaw = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT,
+    eQueryPerformanceCounter = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( TimeDomainEXT value )
+  {
+    switch ( value )
+    {
+      case TimeDomainEXT::eDevice : return "Device";
+      case TimeDomainEXT::eClockMonotonic : return "ClockMonotonic";
+      case TimeDomainEXT::eClockMonotonicRaw : return "ClockMonotonicRaw";
+      case TimeDomainEXT::eQueryPerformanceCounter : return "QueryPerformanceCounter";
+      default: return "invalid";
+    }
+  }
+
+  enum class ValidationCacheHeaderVersionEXT
+  {
+    eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ValidationCacheHeaderVersionEXT value )
+  {
+    switch ( value )
+    {
+      case ValidationCacheHeaderVersionEXT::eOne : return "One";
+      default: return "invalid";
+    }
+  }
+
+  enum class ValidationCheckEXT
+  {
+    eAll = VK_VALIDATION_CHECK_ALL_EXT,
+    eShaders = VK_VALIDATION_CHECK_SHADERS_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ValidationCheckEXT value )
+  {
+    switch ( value )
+    {
+      case ValidationCheckEXT::eAll : return "All";
+      case ValidationCheckEXT::eShaders : return "Shaders";
+      default: return "invalid";
+    }
+  }
+
+  enum class VendorId
+  {
+    eVIV = VK_VENDOR_ID_VIV,
+    eVSI = VK_VENDOR_ID_VSI,
+    eKazan = VK_VENDOR_ID_KAZAN
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( VendorId value )
+  {
+    switch ( value )
+    {
+      case VendorId::eVIV : return "VIV";
+      case VendorId::eVSI : return "VSI";
+      case VendorId::eKazan : return "Kazan";
+      default: return "invalid";
+    }
+  }
+
+  enum class VertexInputRate
+  {
+    eVertex = VK_VERTEX_INPUT_RATE_VERTEX,
+    eInstance = VK_VERTEX_INPUT_RATE_INSTANCE
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( VertexInputRate value )
+  {
+    switch ( value )
+    {
+      case VertexInputRate::eVertex : return "Vertex";
+      case VertexInputRate::eInstance : return "Instance";
+      default: return "invalid";
+    }
+  }
+
+  enum class ViewportCoordinateSwizzleNV
+  {
+    ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
+    eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV,
+    ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV,
+    eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV,
+    ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV,
+    eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV,
+    ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV,
+    eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ViewportCoordinateSwizzleNV value )
+  {
+    switch ( value )
+    {
+      case ViewportCoordinateSwizzleNV::ePositiveX : return "PositiveX";
+      case ViewportCoordinateSwizzleNV::eNegativeX : return "NegativeX";
+      case ViewportCoordinateSwizzleNV::ePositiveY : return "PositiveY";
+      case ViewportCoordinateSwizzleNV::eNegativeY : return "NegativeY";
+      case ViewportCoordinateSwizzleNV::ePositiveZ : return "PositiveZ";
+      case ViewportCoordinateSwizzleNV::eNegativeZ : return "NegativeZ";
+      case ViewportCoordinateSwizzleNV::ePositiveW : return "PositiveW";
+      case ViewportCoordinateSwizzleNV::eNegativeW : return "NegativeW";
+      default: return "invalid";
+    }
+  }
+
+  enum class AccessFlagBits
+  {
+    eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
+    eIndexRead = VK_ACCESS_INDEX_READ_BIT,
+    eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
+    eUniformRead = VK_ACCESS_UNIFORM_READ_BIT,
+    eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
+    eShaderRead = VK_ACCESS_SHADER_READ_BIT,
+    eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT,
+    eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
+    eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+    eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
+    eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+    eTransferRead = VK_ACCESS_TRANSFER_READ_BIT,
+    eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT,
+    eHostRead = VK_ACCESS_HOST_READ_BIT,
+    eHostWrite = VK_ACCESS_HOST_WRITE_BIT,
+    eMemoryRead = VK_ACCESS_MEMORY_READ_BIT,
+    eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT,
+    eTransformFeedbackWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
+    eTransformFeedbackCounterReadEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
+    eTransformFeedbackCounterWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
+    eConditionalRenderingReadEXT = VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT,
+    eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX,
+    eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX,
+    eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT,
+    eShadingRateImageReadNV = VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV,
+    eAccelerationStructureReadNV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV,
+    eAccelerationStructureWriteNV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV,
+    eFragmentDensityMapReadEXT = VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( AccessFlagBits value )
+  {
+    switch ( value )
+    {
+      case AccessFlagBits::eIndirectCommandRead : return "IndirectCommandRead";
+      case AccessFlagBits::eIndexRead : return "IndexRead";
+      case AccessFlagBits::eVertexAttributeRead : return "VertexAttributeRead";
+      case AccessFlagBits::eUniformRead : return "UniformRead";
+      case AccessFlagBits::eInputAttachmentRead : return "InputAttachmentRead";
+      case AccessFlagBits::eShaderRead : return "ShaderRead";
+      case AccessFlagBits::eShaderWrite : return "ShaderWrite";
+      case AccessFlagBits::eColorAttachmentRead : return "ColorAttachmentRead";
+      case AccessFlagBits::eColorAttachmentWrite : return "ColorAttachmentWrite";
+      case AccessFlagBits::eDepthStencilAttachmentRead : return "DepthStencilAttachmentRead";
+      case AccessFlagBits::eDepthStencilAttachmentWrite : return "DepthStencilAttachmentWrite";
+      case AccessFlagBits::eTransferRead : return "TransferRead";
+      case AccessFlagBits::eTransferWrite : return "TransferWrite";
+      case AccessFlagBits::eHostRead : return "HostRead";
+      case AccessFlagBits::eHostWrite : return "HostWrite";
+      case AccessFlagBits::eMemoryRead : return "MemoryRead";
+      case AccessFlagBits::eMemoryWrite : return "MemoryWrite";
+      case AccessFlagBits::eTransformFeedbackWriteEXT : return "TransformFeedbackWriteEXT";
+      case AccessFlagBits::eTransformFeedbackCounterReadEXT : return "TransformFeedbackCounterReadEXT";
+      case AccessFlagBits::eTransformFeedbackCounterWriteEXT : return "TransformFeedbackCounterWriteEXT";
+      case AccessFlagBits::eConditionalRenderingReadEXT : return "ConditionalRenderingReadEXT";
+      case AccessFlagBits::eCommandProcessReadNVX : return "CommandProcessReadNVX";
+      case AccessFlagBits::eCommandProcessWriteNVX : return "CommandProcessWriteNVX";
+      case AccessFlagBits::eColorAttachmentReadNoncoherentEXT : return "ColorAttachmentReadNoncoherentEXT";
+      case AccessFlagBits::eShadingRateImageReadNV : return "ShadingRateImageReadNV";
+      case AccessFlagBits::eAccelerationStructureReadNV : return "AccelerationStructureReadNV";
+      case AccessFlagBits::eAccelerationStructureWriteNV : return "AccelerationStructureWriteNV";
+      case AccessFlagBits::eFragmentDensityMapReadEXT : return "FragmentDensityMapReadEXT";
+      default: return "invalid";
+    }
+  }
+
+  using AccessFlags = Flags<AccessFlagBits, VkAccessFlags>;
+
+  VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 )
+  {
+    return AccessFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits )
+  {
+    return ~( AccessFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<AccessFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eTransformFeedbackWriteEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterReadEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterWriteEXT) | VkFlags(AccessFlagBits::eConditionalRenderingReadEXT) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) | VkFlags(AccessFlagBits::eShadingRateImageReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureWriteNV) | VkFlags(AccessFlagBits::eFragmentDensityMapReadEXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( AccessFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & AccessFlagBits::eIndirectCommandRead ) result += "IndirectCommandRead | ";
+    if ( value & AccessFlagBits::eIndexRead ) result += "IndexRead | ";
+    if ( value & AccessFlagBits::eVertexAttributeRead ) result += "VertexAttributeRead | ";
+    if ( value & AccessFlagBits::eUniformRead ) result += "UniformRead | ";
+    if ( value & AccessFlagBits::eInputAttachmentRead ) result += "InputAttachmentRead | ";
+    if ( value & AccessFlagBits::eShaderRead ) result += "ShaderRead | ";
+    if ( value & AccessFlagBits::eShaderWrite ) result += "ShaderWrite | ";
+    if ( value & AccessFlagBits::eColorAttachmentRead ) result += "ColorAttachmentRead | ";
+    if ( value & AccessFlagBits::eColorAttachmentWrite ) result += "ColorAttachmentWrite | ";
+    if ( value & AccessFlagBits::eDepthStencilAttachmentRead ) result += "DepthStencilAttachmentRead | ";
+    if ( value & AccessFlagBits::eDepthStencilAttachmentWrite ) result += "DepthStencilAttachmentWrite | ";
+    if ( value & AccessFlagBits::eTransferRead ) result += "TransferRead | ";
+    if ( value & AccessFlagBits::eTransferWrite ) result += "TransferWrite | ";
+    if ( value & AccessFlagBits::eHostRead ) result += "HostRead | ";
+    if ( value & AccessFlagBits::eHostWrite ) result += "HostWrite | ";
+    if ( value & AccessFlagBits::eMemoryRead ) result += "MemoryRead | ";
+    if ( value & AccessFlagBits::eMemoryWrite ) result += "MemoryWrite | ";
+    if ( value & AccessFlagBits::eTransformFeedbackWriteEXT ) result += "TransformFeedbackWriteEXT | ";
+    if ( value & AccessFlagBits::eTransformFeedbackCounterReadEXT ) result += "TransformFeedbackCounterReadEXT | ";
+    if ( value & AccessFlagBits::eTransformFeedbackCounterWriteEXT ) result += "TransformFeedbackCounterWriteEXT | ";
+    if ( value & AccessFlagBits::eConditionalRenderingReadEXT ) result += "ConditionalRenderingReadEXT | ";
+    if ( value & AccessFlagBits::eCommandProcessReadNVX ) result += "CommandProcessReadNVX | ";
+    if ( value & AccessFlagBits::eCommandProcessWriteNVX ) result += "CommandProcessWriteNVX | ";
+    if ( value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT ) result += "ColorAttachmentReadNoncoherentEXT | ";
+    if ( value & AccessFlagBits::eShadingRateImageReadNV ) result += "ShadingRateImageReadNV | ";
+    if ( value & AccessFlagBits::eAccelerationStructureReadNV ) result += "AccelerationStructureReadNV | ";
+    if ( value & AccessFlagBits::eAccelerationStructureWriteNV ) result += "AccelerationStructureWriteNV | ";
+    if ( value & AccessFlagBits::eFragmentDensityMapReadEXT ) result += "FragmentDensityMapReadEXT";
+  }
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  enum class AndroidSurfaceCreateFlagBitsKHR
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+
+  using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR, VkAndroidSurfaceCreateFlagsKHR>;
+
+  VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagsKHR  )
+  {
+    return "{}";
+  }
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+  enum class AttachmentDescriptionFlagBits
+  {
+    eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlagBits value )
+  {
+    switch ( value )
+    {
+      case AttachmentDescriptionFlagBits::eMayAlias : return "MayAlias";
+      default: return "invalid";
+    }
+  }
+
+  using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits, VkAttachmentDescriptionFlags>;
+
+  VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
+  {
+    return AttachmentDescriptionFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits )
+  {
+    return ~( AttachmentDescriptionFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<AttachmentDescriptionFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & AttachmentDescriptionFlagBits::eMayAlias ) result += "MayAlias";
+  }
+
+  enum class BufferCreateFlagBits
+  {
+    eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
+    eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
+    eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
+    eProtected = VK_BUFFER_CREATE_PROTECTED_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BufferCreateFlagBits value )
+  {
+    switch ( value )
+    {
+      case BufferCreateFlagBits::eSparseBinding : return "SparseBinding";
+      case BufferCreateFlagBits::eSparseResidency : return "SparseResidency";
+      case BufferCreateFlagBits::eSparseAliased : return "SparseAliased";
+      case BufferCreateFlagBits::eProtected : return "Protected";
+      default: return "invalid";
+    }
+  }
+
+  using BufferCreateFlags = Flags<BufferCreateFlagBits, VkBufferCreateFlags>;
+
+  VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
+  {
+    return BufferCreateFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits )
+  {
+    return ~( BufferCreateFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<BufferCreateFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased) | VkFlags(BufferCreateFlagBits::eProtected)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BufferCreateFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & BufferCreateFlagBits::eSparseBinding ) result += "SparseBinding | ";
+    if ( value & BufferCreateFlagBits::eSparseResidency ) result += "SparseResidency | ";
+    if ( value & BufferCreateFlagBits::eSparseAliased ) result += "SparseAliased | ";
+    if ( value & BufferCreateFlagBits::eProtected ) result += "Protected";
+  }
+
+  enum class BufferUsageFlagBits
+  {
+    eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+    eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+    eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
+    eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
+    eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+    eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
+    eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
+    eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+    eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
+    eTransformFeedbackBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT,
+    eTransformFeedbackCounterBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT,
+    eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT,
+    eRayTracingNV = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BufferUsageFlagBits value )
+  {
+    switch ( value )
+    {
+      case BufferUsageFlagBits::eTransferSrc : return "TransferSrc";
+      case BufferUsageFlagBits::eTransferDst : return "TransferDst";
+      case BufferUsageFlagBits::eUniformTexelBuffer : return "UniformTexelBuffer";
+      case BufferUsageFlagBits::eStorageTexelBuffer : return "StorageTexelBuffer";
+      case BufferUsageFlagBits::eUniformBuffer : return "UniformBuffer";
+      case BufferUsageFlagBits::eStorageBuffer : return "StorageBuffer";
+      case BufferUsageFlagBits::eIndexBuffer : return "IndexBuffer";
+      case BufferUsageFlagBits::eVertexBuffer : return "VertexBuffer";
+      case BufferUsageFlagBits::eIndirectBuffer : return "IndirectBuffer";
+      case BufferUsageFlagBits::eTransformFeedbackBufferEXT : return "TransformFeedbackBufferEXT";
+      case BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT : return "TransformFeedbackCounterBufferEXT";
+      case BufferUsageFlagBits::eConditionalRenderingEXT : return "ConditionalRenderingEXT";
+      case BufferUsageFlagBits::eRayTracingNV : return "RayTracingNV";
+      default: return "invalid";
+    }
+  }
+
+  using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>;
+
+  VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
+  {
+    return BufferUsageFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits )
+  {
+    return ~( BufferUsageFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<BufferUsageFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) | VkFlags(BufferUsageFlagBits::eTransformFeedbackBufferEXT) | VkFlags(BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) | VkFlags(BufferUsageFlagBits::eConditionalRenderingEXT) | VkFlags(BufferUsageFlagBits::eRayTracingNV)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BufferUsageFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & BufferUsageFlagBits::eTransferSrc ) result += "TransferSrc | ";
+    if ( value & BufferUsageFlagBits::eTransferDst ) result += "TransferDst | ";
+    if ( value & BufferUsageFlagBits::eUniformTexelBuffer ) result += "UniformTexelBuffer | ";
+    if ( value & BufferUsageFlagBits::eStorageTexelBuffer ) result += "StorageTexelBuffer | ";
+    if ( value & BufferUsageFlagBits::eUniformBuffer ) result += "UniformBuffer | ";
+    if ( value & BufferUsageFlagBits::eStorageBuffer ) result += "StorageBuffer | ";
+    if ( value & BufferUsageFlagBits::eIndexBuffer ) result += "IndexBuffer | ";
+    if ( value & BufferUsageFlagBits::eVertexBuffer ) result += "VertexBuffer | ";
+    if ( value & BufferUsageFlagBits::eIndirectBuffer ) result += "IndirectBuffer | ";
+    if ( value & BufferUsageFlagBits::eTransformFeedbackBufferEXT ) result += "TransformFeedbackBufferEXT | ";
+    if ( value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT ) result += "TransformFeedbackCounterBufferEXT | ";
+    if ( value & BufferUsageFlagBits::eConditionalRenderingEXT ) result += "ConditionalRenderingEXT | ";
+    if ( value & BufferUsageFlagBits::eRayTracingNV ) result += "RayTracingNV";
+  }
+
+  enum class BufferViewCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits, VkBufferViewCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class BuildAccelerationStructureFlagBitsNV
+  {
+    eAllowUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV,
+    eAllowCompaction = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV,
+    ePreferFastTrace = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV,
+    ePreferFastBuild = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV,
+    eLowMemory = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BuildAccelerationStructureFlagBitsNV value )
+  {
+    switch ( value )
+    {
+      case BuildAccelerationStructureFlagBitsNV::eAllowUpdate : return "AllowUpdate";
+      case BuildAccelerationStructureFlagBitsNV::eAllowCompaction : return "AllowCompaction";
+      case BuildAccelerationStructureFlagBitsNV::ePreferFastTrace : return "PreferFastTrace";
+      case BuildAccelerationStructureFlagBitsNV::ePreferFastBuild : return "PreferFastBuild";
+      case BuildAccelerationStructureFlagBitsNV::eLowMemory : return "LowMemory";
+      default: return "invalid";
+    }
+  }
+
+  using BuildAccelerationStructureFlagsNV = Flags<BuildAccelerationStructureFlagBitsNV, VkBuildAccelerationStructureFlagsNV>;
+
+  VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator|( BuildAccelerationStructureFlagBitsNV bit0, BuildAccelerationStructureFlagBitsNV bit1 )
+  {
+    return BuildAccelerationStructureFlagsNV( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator~( BuildAccelerationStructureFlagBitsNV bits )
+  {
+    return ~( BuildAccelerationStructureFlagsNV( bits ) );
+  }
+
+  template <> struct FlagTraits<BuildAccelerationStructureFlagBitsNV>
+  {
+    enum
+    {
+      allFlags = VkFlags(BuildAccelerationStructureFlagBitsNV::eAllowUpdate) | VkFlags(BuildAccelerationStructureFlagBitsNV::eAllowCompaction) | VkFlags(BuildAccelerationStructureFlagBitsNV::ePreferFastTrace) | VkFlags(BuildAccelerationStructureFlagBitsNV::ePreferFastBuild) | VkFlags(BuildAccelerationStructureFlagBitsNV::eLowMemory)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BuildAccelerationStructureFlagsNV value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & BuildAccelerationStructureFlagBitsNV::eAllowUpdate ) result += "AllowUpdate | ";
+    if ( value & BuildAccelerationStructureFlagBitsNV::eAllowCompaction ) result += "AllowCompaction | ";
+    if ( value & BuildAccelerationStructureFlagBitsNV::ePreferFastTrace ) result += "PreferFastTrace | ";
+    if ( value & BuildAccelerationStructureFlagBitsNV::ePreferFastBuild ) result += "PreferFastBuild | ";
+    if ( value & BuildAccelerationStructureFlagBitsNV::eLowMemory ) result += "LowMemory";
+  }
+
+  enum class ColorComponentFlagBits
+  {
+    eR = VK_COLOR_COMPONENT_R_BIT,
+    eG = VK_COLOR_COMPONENT_G_BIT,
+    eB = VK_COLOR_COMPONENT_B_BIT,
+    eA = VK_COLOR_COMPONENT_A_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ColorComponentFlagBits value )
+  {
+    switch ( value )
+    {
+      case ColorComponentFlagBits::eR : return "R";
+      case ColorComponentFlagBits::eG : return "G";
+      case ColorComponentFlagBits::eB : return "B";
+      case ColorComponentFlagBits::eA : return "A";
+      default: return "invalid";
+    }
+  }
+
+  using ColorComponentFlags = Flags<ColorComponentFlagBits, VkColorComponentFlags>;
+
+  VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
+  {
+    return ColorComponentFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits )
+  {
+    return ~( ColorComponentFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<ColorComponentFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(ColorComponentFlagBits::eR) | VkFlags(ColorComponentFlagBits::eG) | VkFlags(ColorComponentFlagBits::eB) | VkFlags(ColorComponentFlagBits::eA)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ColorComponentFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ColorComponentFlagBits::eR ) result += "R | ";
+    if ( value & ColorComponentFlagBits::eG ) result += "G | ";
+    if ( value & ColorComponentFlagBits::eB ) result += "B | ";
+    if ( value & ColorComponentFlagBits::eA ) result += "A";
+  }
+
+  enum class CommandBufferResetFlagBits
+  {
+    eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlagBits value )
+  {
+    switch ( value )
+    {
+      case CommandBufferResetFlagBits::eReleaseResources : return "ReleaseResources";
+      default: return "invalid";
+    }
+  }
+
+  using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits, VkCommandBufferResetFlags>;
+
+  VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
+  {
+    return CommandBufferResetFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits )
+  {
+    return ~( CommandBufferResetFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<CommandBufferResetFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & CommandBufferResetFlagBits::eReleaseResources ) result += "ReleaseResources";
+  }
+
+  enum class CommandBufferUsageFlagBits
+  {
+    eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+    eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
+    eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CommandBufferUsageFlagBits value )
+  {
+    switch ( value )
+    {
+      case CommandBufferUsageFlagBits::eOneTimeSubmit : return "OneTimeSubmit";
+      case CommandBufferUsageFlagBits::eRenderPassContinue : return "RenderPassContinue";
+      case CommandBufferUsageFlagBits::eSimultaneousUse : return "SimultaneousUse";
+      default: return "invalid";
+    }
+  }
+
+  using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits, VkCommandBufferUsageFlags>;
+
+  VULKAN_HPP_INLINE CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
+  {
+    return CommandBufferUsageFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits )
+  {
+    return ~( CommandBufferUsageFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<CommandBufferUsageFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) | VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) | VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CommandBufferUsageFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & CommandBufferUsageFlagBits::eOneTimeSubmit ) result += "OneTimeSubmit | ";
+    if ( value & CommandBufferUsageFlagBits::eRenderPassContinue ) result += "RenderPassContinue | ";
+    if ( value & CommandBufferUsageFlagBits::eSimultaneousUse ) result += "SimultaneousUse";
+  }
+
+  enum class CommandPoolCreateFlagBits
+  {
+    eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
+    eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
+    eProtected = VK_COMMAND_POOL_CREATE_PROTECTED_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CommandPoolCreateFlagBits value )
+  {
+    switch ( value )
+    {
+      case CommandPoolCreateFlagBits::eTransient : return "Transient";
+      case CommandPoolCreateFlagBits::eResetCommandBuffer : return "ResetCommandBuffer";
+      case CommandPoolCreateFlagBits::eProtected : return "Protected";
+      default: return "invalid";
+    }
+  }
+
+  using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits, VkCommandPoolCreateFlags>;
+
+  VULKAN_HPP_INLINE CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
+  {
+    return CommandPoolCreateFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits )
+  {
+    return ~( CommandPoolCreateFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<CommandPoolCreateFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) | VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer) | VkFlags(CommandPoolCreateFlagBits::eProtected)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CommandPoolCreateFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & CommandPoolCreateFlagBits::eTransient ) result += "Transient | ";
+    if ( value & CommandPoolCreateFlagBits::eResetCommandBuffer ) result += "ResetCommandBuffer | ";
+    if ( value & CommandPoolCreateFlagBits::eProtected ) result += "Protected";
+  }
+
+  enum class CommandPoolResetFlagBits
+  {
+    eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CommandPoolResetFlagBits value )
+  {
+    switch ( value )
+    {
+      case CommandPoolResetFlagBits::eReleaseResources : return "ReleaseResources";
+      default: return "invalid";
+    }
+  }
+
+  using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits, VkCommandPoolResetFlags>;
+
+  VULKAN_HPP_INLINE CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
+  {
+    return CommandPoolResetFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits )
+  {
+    return ~( CommandPoolResetFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<CommandPoolResetFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CommandPoolResetFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & CommandPoolResetFlagBits::eReleaseResources ) result += "ReleaseResources";
+  }
+
+  enum class CommandPoolTrimFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( CommandPoolTrimFlagBits )
+  {
+    return "(void)";
+  }
+
+  using CommandPoolTrimFlags = Flags<CommandPoolTrimFlagBits, VkCommandPoolTrimFlags>;
+
+  using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags;
+
+  VULKAN_HPP_INLINE std::string to_string( CommandPoolTrimFlags  )
+  {
+    return "{}";
+  }
+
+  enum class CompositeAlphaFlagBitsKHR
+  {
+    eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
+    ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
+    ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
+    eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CompositeAlphaFlagBitsKHR value )
+  {
+    switch ( value )
+    {
+      case CompositeAlphaFlagBitsKHR::eOpaque : return "Opaque";
+      case CompositeAlphaFlagBitsKHR::ePreMultiplied : return "PreMultiplied";
+      case CompositeAlphaFlagBitsKHR::ePostMultiplied : return "PostMultiplied";
+      case CompositeAlphaFlagBitsKHR::eInherit : return "Inherit";
+      default: return "invalid";
+    }
+  }
+
+  using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR, VkCompositeAlphaFlagsKHR>;
+
+  VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
+  {
+    return CompositeAlphaFlagsKHR( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits )
+  {
+    return ~( CompositeAlphaFlagsKHR( bits ) );
+  }
+
+  template <> struct FlagTraits<CompositeAlphaFlagBitsKHR>
+  {
+    enum
+    {
+      allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) | VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::eInherit)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CompositeAlphaFlagsKHR value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & CompositeAlphaFlagBitsKHR::eOpaque ) result += "Opaque | ";
+    if ( value & CompositeAlphaFlagBitsKHR::ePreMultiplied ) result += "PreMultiplied | ";
+    if ( value & CompositeAlphaFlagBitsKHR::ePostMultiplied ) result += "PostMultiplied | ";
+    if ( value & CompositeAlphaFlagBitsKHR::eInherit ) result += "Inherit";
+  }
+
+  enum class ConditionalRenderingFlagBitsEXT
+  {
+    eInverted = VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ConditionalRenderingFlagBitsEXT value )
+  {
+    switch ( value )
+    {
+      case ConditionalRenderingFlagBitsEXT::eInverted : return "Inverted";
+      default: return "invalid";
+    }
+  }
+
+  using ConditionalRenderingFlagsEXT = Flags<ConditionalRenderingFlagBitsEXT, VkConditionalRenderingFlagsEXT>;
+
+  VULKAN_HPP_INLINE ConditionalRenderingFlagsEXT operator|( ConditionalRenderingFlagBitsEXT bit0, ConditionalRenderingFlagBitsEXT bit1 )
+  {
+    return ConditionalRenderingFlagsEXT( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ConditionalRenderingFlagsEXT operator~( ConditionalRenderingFlagBitsEXT bits )
+  {
+    return ~( ConditionalRenderingFlagsEXT( bits ) );
+  }
+
+  template <> struct FlagTraits<ConditionalRenderingFlagBitsEXT>
+  {
+    enum
+    {
+      allFlags = VkFlags(ConditionalRenderingFlagBitsEXT::eInverted)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ConditionalRenderingFlagsEXT value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ConditionalRenderingFlagBitsEXT::eInverted ) result += "Inverted";
+  }
+
+  enum class CullModeFlagBits
+  {
+    eNone = VK_CULL_MODE_NONE,
+    eFront = VK_CULL_MODE_FRONT_BIT,
+    eBack = VK_CULL_MODE_BACK_BIT,
+    eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CullModeFlagBits value )
+  {
+    switch ( value )
+    {
+      case CullModeFlagBits::eNone : return "None";
+      case CullModeFlagBits::eFront : return "Front";
+      case CullModeFlagBits::eBack : return "Back";
+      case CullModeFlagBits::eFrontAndBack : return "FrontAndBack";
+      default: return "invalid";
+    }
+  }
+
+  using CullModeFlags = Flags<CullModeFlagBits, VkCullModeFlags>;
+
+  VULKAN_HPP_INLINE CullModeFlags operator|( CullModeFlagBits bit0, CullModeFlagBits bit1 )
+  {
+    return CullModeFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE CullModeFlags operator~( CullModeFlagBits bits )
+  {
+    return ~( CullModeFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<CullModeFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(CullModeFlagBits::eNone) | VkFlags(CullModeFlagBits::eFront) | VkFlags(CullModeFlagBits::eBack) | VkFlags(CullModeFlagBits::eFrontAndBack)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CullModeFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & CullModeFlagBits::eNone ) result += "None | ";
+    if ( value & CullModeFlagBits::eFront ) result += "Front | ";
+    if ( value & CullModeFlagBits::eBack ) result += "Back | ";
+    if ( value & CullModeFlagBits::eFrontAndBack ) result += "FrontAndBack";
+  }
+
+  enum class DebugReportFlagBitsEXT
+  {
+    eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
+    eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT,
+    ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
+    eError = VK_DEBUG_REPORT_ERROR_BIT_EXT,
+    eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DebugReportFlagBitsEXT value )
+  {
+    switch ( value )
+    {
+      case DebugReportFlagBitsEXT::eInformation : return "Information";
+      case DebugReportFlagBitsEXT::eWarning : return "Warning";
+      case DebugReportFlagBitsEXT::ePerformanceWarning : return "PerformanceWarning";
+      case DebugReportFlagBitsEXT::eError : return "Error";
+      case DebugReportFlagBitsEXT::eDebug : return "Debug";
+      default: return "invalid";
+    }
+  }
+
+  using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT, VkDebugReportFlagsEXT>;
+
+  VULKAN_HPP_INLINE DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
+  {
+    return DebugReportFlagsEXT( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits )
+  {
+    return ~( DebugReportFlagsEXT( bits ) );
+  }
+
+  template <> struct FlagTraits<DebugReportFlagBitsEXT>
+  {
+    enum
+    {
+      allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) | VkFlags(DebugReportFlagBitsEXT::eWarning) | VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) | VkFlags(DebugReportFlagBitsEXT::eError) | VkFlags(DebugReportFlagBitsEXT::eDebug)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DebugReportFlagsEXT value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & DebugReportFlagBitsEXT::eInformation ) result += "Information | ";
+    if ( value & DebugReportFlagBitsEXT::eWarning ) result += "Warning | ";
+    if ( value & DebugReportFlagBitsEXT::ePerformanceWarning ) result += "PerformanceWarning | ";
+    if ( value & DebugReportFlagBitsEXT::eError ) result += "Error | ";
+    if ( value & DebugReportFlagBitsEXT::eDebug ) result += "Debug";
+  }
+
+  enum class DebugUtilsMessageSeverityFlagBitsEXT
+  {
+    eVerbose = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT,
+    eInfo = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT,
+    eWarning = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT,
+    eError = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageSeverityFlagBitsEXT value )
+  {
+    switch ( value )
+    {
+      case DebugUtilsMessageSeverityFlagBitsEXT::eVerbose : return "Verbose";
+      case DebugUtilsMessageSeverityFlagBitsEXT::eInfo : return "Info";
+      case DebugUtilsMessageSeverityFlagBitsEXT::eWarning : return "Warning";
+      case DebugUtilsMessageSeverityFlagBitsEXT::eError : return "Error";
+      default: return "invalid";
+    }
+  }
+
+  using DebugUtilsMessageSeverityFlagsEXT = Flags<DebugUtilsMessageSeverityFlagBitsEXT, VkDebugUtilsMessageSeverityFlagsEXT>;
+
+  VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator|( DebugUtilsMessageSeverityFlagBitsEXT bit0, DebugUtilsMessageSeverityFlagBitsEXT bit1 )
+  {
+    return DebugUtilsMessageSeverityFlagsEXT( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator~( DebugUtilsMessageSeverityFlagBitsEXT bits )
+  {
+    return ~( DebugUtilsMessageSeverityFlagsEXT( bits ) );
+  }
+
+  template <> struct FlagTraits<DebugUtilsMessageSeverityFlagBitsEXT>
+  {
+    enum
+    {
+      allFlags = VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eVerbose) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eInfo) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eWarning) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eError)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageSeverityFlagsEXT value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eVerbose ) result += "Verbose | ";
+    if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eInfo ) result += "Info | ";
+    if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eWarning ) result += "Warning | ";
+    if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eError ) result += "Error";
+  }
+
+  enum class DebugUtilsMessageTypeFlagBitsEXT
+  {
+    eGeneral = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT,
+    eValidation = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
+    ePerformance = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageTypeFlagBitsEXT value )
+  {
+    switch ( value )
+    {
+      case DebugUtilsMessageTypeFlagBitsEXT::eGeneral : return "General";
+      case DebugUtilsMessageTypeFlagBitsEXT::eValidation : return "Validation";
+      case DebugUtilsMessageTypeFlagBitsEXT::ePerformance : return "Performance";
+      default: return "invalid";
+    }
+  }
+
+  using DebugUtilsMessageTypeFlagsEXT = Flags<DebugUtilsMessageTypeFlagBitsEXT, VkDebugUtilsMessageTypeFlagsEXT>;
+
+  VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator|( DebugUtilsMessageTypeFlagBitsEXT bit0, DebugUtilsMessageTypeFlagBitsEXT bit1 )
+  {
+    return DebugUtilsMessageTypeFlagsEXT( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator~( DebugUtilsMessageTypeFlagBitsEXT bits )
+  {
+    return ~( DebugUtilsMessageTypeFlagsEXT( bits ) );
+  }
+
+  template <> struct FlagTraits<DebugUtilsMessageTypeFlagBitsEXT>
+  {
+    enum
+    {
+      allFlags = VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eGeneral) | VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eValidation) | VkFlags(DebugUtilsMessageTypeFlagBitsEXT::ePerformance)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageTypeFlagsEXT value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & DebugUtilsMessageTypeFlagBitsEXT::eGeneral ) result += "General | ";
+    if ( value & DebugUtilsMessageTypeFlagBitsEXT::eValidation ) result += "Validation | ";
+    if ( value & DebugUtilsMessageTypeFlagBitsEXT::ePerformance ) result += "Performance";
+  }
+
+  enum class DebugUtilsMessengerCallbackDataFlagBitsEXT
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
+  using DebugUtilsMessengerCallbackDataFlagsEXT = Flags<DebugUtilsMessengerCallbackDataFlagBitsEXT, VkDebugUtilsMessengerCallbackDataFlagsEXT>;
+
+  VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagsEXT  )
+  {
+    return "{}";
+  }
+
+  enum class DebugUtilsMessengerCreateFlagBitsEXT
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
+  using DebugUtilsMessengerCreateFlagsEXT = Flags<DebugUtilsMessengerCreateFlagBitsEXT, VkDebugUtilsMessengerCreateFlagsEXT>;
+
+  VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagsEXT  )
+  {
+    return "{}";
+  }
+
+  enum class DependencyFlagBits
+  {
+    eByRegion = VK_DEPENDENCY_BY_REGION_BIT,
+    eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT,
+    eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT,
+    eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR,
+    eDeviceGroupKHR = VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DependencyFlagBits value )
+  {
+    switch ( value )
+    {
+      case DependencyFlagBits::eByRegion : return "ByRegion";
+      case DependencyFlagBits::eDeviceGroup : return "DeviceGroup";
+      case DependencyFlagBits::eViewLocal : return "ViewLocal";
+      default: return "invalid";
+    }
+  }
+
+  using DependencyFlags = Flags<DependencyFlagBits, VkDependencyFlags>;
+
+  VULKAN_HPP_INLINE DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 )
+  {
+    return DependencyFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE DependencyFlags operator~( DependencyFlagBits bits )
+  {
+    return ~( DependencyFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<DependencyFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(DependencyFlagBits::eByRegion) | VkFlags(DependencyFlagBits::eDeviceGroup) | VkFlags(DependencyFlagBits::eViewLocal)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DependencyFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & DependencyFlagBits::eByRegion ) result += "ByRegion | ";
+    if ( value & DependencyFlagBits::eDeviceGroup ) result += "DeviceGroup | ";
+    if ( value & DependencyFlagBits::eViewLocal ) result += "ViewLocal";
+  }
+
+  enum class DescriptorBindingFlagBitsEXT
+  {
+    eUpdateAfterBind = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT,
+    eUpdateUnusedWhilePending = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT,
+    ePartiallyBound = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT,
+    eVariableDescriptorCount = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorBindingFlagBitsEXT value )
+  {
+    switch ( value )
+    {
+      case DescriptorBindingFlagBitsEXT::eUpdateAfterBind : return "UpdateAfterBind";
+      case DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending : return "UpdateUnusedWhilePending";
+      case DescriptorBindingFlagBitsEXT::ePartiallyBound : return "PartiallyBound";
+      case DescriptorBindingFlagBitsEXT::eVariableDescriptorCount : return "VariableDescriptorCount";
+      default: return "invalid";
+    }
+  }
+
+  using DescriptorBindingFlagsEXT = Flags<DescriptorBindingFlagBitsEXT, VkDescriptorBindingFlagsEXT>;
+
+  VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator|( DescriptorBindingFlagBitsEXT bit0, DescriptorBindingFlagBitsEXT bit1 )
+  {
+    return DescriptorBindingFlagsEXT( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator~( DescriptorBindingFlagBitsEXT bits )
+  {
+    return ~( DescriptorBindingFlagsEXT( bits ) );
+  }
+
+  template <> struct FlagTraits<DescriptorBindingFlagBitsEXT>
+  {
+    enum
+    {
+      allFlags = VkFlags(DescriptorBindingFlagBitsEXT::eUpdateAfterBind) | VkFlags(DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending) | VkFlags(DescriptorBindingFlagBitsEXT::ePartiallyBound) | VkFlags(DescriptorBindingFlagBitsEXT::eVariableDescriptorCount)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorBindingFlagsEXT value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & DescriptorBindingFlagBitsEXT::eUpdateAfterBind ) result += "UpdateAfterBind | ";
+    if ( value & DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending ) result += "UpdateUnusedWhilePending | ";
+    if ( value & DescriptorBindingFlagBitsEXT::ePartiallyBound ) result += "PartiallyBound | ";
+    if ( value & DescriptorBindingFlagBitsEXT::eVariableDescriptorCount ) result += "VariableDescriptorCount";
+  }
+
+  enum class DescriptorPoolCreateFlagBits
+  {
+    eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
+    eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorPoolCreateFlagBits value )
+  {
+    switch ( value )
+    {
+      case DescriptorPoolCreateFlagBits::eFreeDescriptorSet : return "FreeDescriptorSet";
+      case DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT : return "UpdateAfterBindEXT";
+      default: return "invalid";
+    }
+  }
+
+  using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits, VkDescriptorPoolCreateFlags>;
+
+  VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
+  {
+    return DescriptorPoolCreateFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits )
+  {
+    return ~( DescriptorPoolCreateFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<DescriptorPoolCreateFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) | VkFlags(DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorPoolCreateFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet ) result += "FreeDescriptorSet | ";
+    if ( value & DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT ) result += "UpdateAfterBindEXT";
+  }
+
+  enum class DescriptorPoolResetFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlagBits )
+  {
+    return "(void)";
+  }
+
+  using DescriptorPoolResetFlags = Flags<DescriptorPoolResetFlagBits, VkDescriptorPoolResetFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlags  )
+  {
+    return "{}";
+  }
+
+  enum class DescriptorSetLayoutCreateFlagBits
+  {
+    ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR,
+    eUpdateAfterBindPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorSetLayoutCreateFlagBits value )
+  {
+    switch ( value )
+    {
+      case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR : return "PushDescriptorKHR";
+      case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT : return "UpdateAfterBindPoolEXT";
+      default: return "invalid";
+    }
+  }
+
+  using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits, VkDescriptorSetLayoutCreateFlags>;
+
+  VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
+  {
+    return DescriptorSetLayoutCreateFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator~( DescriptorSetLayoutCreateFlagBits bits )
+  {
+    return ~( DescriptorSetLayoutCreateFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<DescriptorSetLayoutCreateFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) | VkFlags(DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorSetLayoutCreateFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR ) result += "PushDescriptorKHR | ";
+    if ( value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT ) result += "UpdateAfterBindPoolEXT";
+  }
+
+  enum class DescriptorUpdateTemplateCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using DescriptorUpdateTemplateCreateFlags = Flags<DescriptorUpdateTemplateCreateFlagBits, VkDescriptorUpdateTemplateCreateFlags>;
+
+  using DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags;
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class DeviceCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using DeviceCreateFlags = Flags<DeviceCreateFlagBits, VkDeviceCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class DeviceGroupPresentModeFlagBitsKHR
+  {
+    eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR,
+    eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR,
+    eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR,
+    eLocalMultiDevice = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DeviceGroupPresentModeFlagBitsKHR value )
+  {
+    switch ( value )
+    {
+      case DeviceGroupPresentModeFlagBitsKHR::eLocal : return "Local";
+      case DeviceGroupPresentModeFlagBitsKHR::eRemote : return "Remote";
+      case DeviceGroupPresentModeFlagBitsKHR::eSum : return "Sum";
+      case DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice : return "LocalMultiDevice";
+      default: return "invalid";
+    }
+  }
+
+  using DeviceGroupPresentModeFlagsKHR = Flags<DeviceGroupPresentModeFlagBitsKHR, VkDeviceGroupPresentModeFlagsKHR>;
+
+  VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator|( DeviceGroupPresentModeFlagBitsKHR bit0, DeviceGroupPresentModeFlagBitsKHR bit1 )
+  {
+    return DeviceGroupPresentModeFlagsKHR( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator~( DeviceGroupPresentModeFlagBitsKHR bits )
+  {
+    return ~( DeviceGroupPresentModeFlagsKHR( bits ) );
+  }
+
+  template <> struct FlagTraits<DeviceGroupPresentModeFlagBitsKHR>
+  {
+    enum
+    {
+      allFlags = VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocal) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eRemote) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eSum) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DeviceGroupPresentModeFlagsKHR value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & DeviceGroupPresentModeFlagBitsKHR::eLocal ) result += "Local | ";
+    if ( value & DeviceGroupPresentModeFlagBitsKHR::eRemote ) result += "Remote | ";
+    if ( value & DeviceGroupPresentModeFlagBitsKHR::eSum ) result += "Sum | ";
+    if ( value & DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice ) result += "LocalMultiDevice";
+  }
+
+  enum class DeviceQueueCreateFlagBits
+  {
+    eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlagBits value )
+  {
+    switch ( value )
+    {
+      case DeviceQueueCreateFlagBits::eProtected : return "Protected";
+      default: return "invalid";
+    }
+  }
+
+  using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits, VkDeviceQueueCreateFlags>;
+
+  VULKAN_HPP_INLINE DeviceQueueCreateFlags operator|( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 )
+  {
+    return DeviceQueueCreateFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE DeviceQueueCreateFlags operator~( DeviceQueueCreateFlagBits bits )
+  {
+    return ~( DeviceQueueCreateFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<DeviceQueueCreateFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(DeviceQueueCreateFlagBits::eProtected)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & DeviceQueueCreateFlagBits::eProtected ) result += "Protected";
+  }
+
+  enum class DisplayModeCreateFlagBitsKHR
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+
+  using DisplayModeCreateFlagsKHR = Flags<DisplayModeCreateFlagBitsKHR, VkDisplayModeCreateFlagsKHR>;
+
+  VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagsKHR  )
+  {
+    return "{}";
+  }
+
+  enum class DisplayPlaneAlphaFlagBitsKHR
+  {
+    eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
+    eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
+    ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
+    ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DisplayPlaneAlphaFlagBitsKHR value )
+  {
+    switch ( value )
+    {
+      case DisplayPlaneAlphaFlagBitsKHR::eOpaque : return "Opaque";
+      case DisplayPlaneAlphaFlagBitsKHR::eGlobal : return "Global";
+      case DisplayPlaneAlphaFlagBitsKHR::ePerPixel : return "PerPixel";
+      case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied : return "PerPixelPremultiplied";
+      default: return "invalid";
+    }
+  }
+
+  using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR, VkDisplayPlaneAlphaFlagsKHR>;
+
+  VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
+  {
+    return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits )
+  {
+    return ~( DisplayPlaneAlphaFlagsKHR( bits ) );
+  }
+
+  template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR>
+  {
+    enum
+    {
+      allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DisplayPlaneAlphaFlagsKHR value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & DisplayPlaneAlphaFlagBitsKHR::eOpaque ) result += "Opaque | ";
+    if ( value & DisplayPlaneAlphaFlagBitsKHR::eGlobal ) result += "Global | ";
+    if ( value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel ) result += "PerPixel | ";
+    if ( value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied ) result += "PerPixelPremultiplied";
+  }
+
+  enum class DisplaySurfaceCreateFlagBitsKHR
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+
+  using DisplaySurfaceCreateFlagsKHR = Flags<DisplaySurfaceCreateFlagBitsKHR, VkDisplaySurfaceCreateFlagsKHR>;
+
+  VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagsKHR  )
+  {
+    return "{}";
+  }
+
+  enum class EventCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( EventCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using EventCreateFlags = Flags<EventCreateFlagBits, VkEventCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( EventCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class ExternalFenceFeatureFlagBits
+  {
+    eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
+    eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT,
+    eExportableKHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR,
+    eImportableKHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalFenceFeatureFlagBits value )
+  {
+    switch ( value )
+    {
+      case ExternalFenceFeatureFlagBits::eExportable : return "Exportable";
+      case ExternalFenceFeatureFlagBits::eImportable : return "Importable";
+      default: return "invalid";
+    }
+  }
+
+  using ExternalFenceFeatureFlags = Flags<ExternalFenceFeatureFlagBits, VkExternalFenceFeatureFlags>;
+
+  VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator|( ExternalFenceFeatureFlagBits bit0, ExternalFenceFeatureFlagBits bit1 )
+  {
+    return ExternalFenceFeatureFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator~( ExternalFenceFeatureFlagBits bits )
+  {
+    return ~( ExternalFenceFeatureFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<ExternalFenceFeatureFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(ExternalFenceFeatureFlagBits::eExportable) | VkFlags(ExternalFenceFeatureFlagBits::eImportable)
+    };
+  };
+
+  using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags;
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalFenceFeatureFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ExternalFenceFeatureFlagBits::eExportable ) result += "Exportable | ";
+    if ( value & ExternalFenceFeatureFlagBits::eImportable ) result += "Importable";
+  }
+
+  enum class ExternalFenceHandleTypeFlagBits
+  {
+    eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
+    eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+    eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+    eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
+    eOpaqueFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
+    eOpaqueWin32KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
+    eOpaqueWin32KmtKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
+    eSyncFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalFenceHandleTypeFlagBits value )
+  {
+    switch ( value )
+    {
+      case ExternalFenceHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd";
+      case ExternalFenceHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32";
+      case ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt : return "OpaqueWin32Kmt";
+      case ExternalFenceHandleTypeFlagBits::eSyncFd : return "SyncFd";
+      default: return "invalid";
+    }
+  }
+
+  using ExternalFenceHandleTypeFlags = Flags<ExternalFenceHandleTypeFlagBits, VkExternalFenceHandleTypeFlags>;
+
+  VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator|( ExternalFenceHandleTypeFlagBits bit0, ExternalFenceHandleTypeFlagBits bit1 )
+  {
+    return ExternalFenceHandleTypeFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator~( ExternalFenceHandleTypeFlagBits bits )
+  {
+    return ~( ExternalFenceHandleTypeFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<ExternalFenceHandleTypeFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalFenceHandleTypeFlagBits::eSyncFd)
+    };
+  };
+
+  using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags;
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalFenceHandleTypeFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueFd ) result += "OpaqueFd | ";
+    if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32 ) result += "OpaqueWin32 | ";
+    if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt ) result += "OpaqueWin32Kmt | ";
+    if ( value & ExternalFenceHandleTypeFlagBits::eSyncFd ) result += "SyncFd";
+  }
+
+  enum class ExternalMemoryFeatureFlagBits
+  {
+    eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
+    eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
+    eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
+    eDedicatedOnlyKHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR,
+    eExportableKHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR,
+    eImportableKHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlagBits value )
+  {
+    switch ( value )
+    {
+      case ExternalMemoryFeatureFlagBits::eDedicatedOnly : return "DedicatedOnly";
+      case ExternalMemoryFeatureFlagBits::eExportable : return "Exportable";
+      case ExternalMemoryFeatureFlagBits::eImportable : return "Importable";
+      default: return "invalid";
+    }
+  }
+
+  using ExternalMemoryFeatureFlags = Flags<ExternalMemoryFeatureFlagBits, VkExternalMemoryFeatureFlags>;
+
+  VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator|( ExternalMemoryFeatureFlagBits bit0, ExternalMemoryFeatureFlagBits bit1 )
+  {
+    return ExternalMemoryFeatureFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator~( ExternalMemoryFeatureFlagBits bits )
+  {
+    return ~( ExternalMemoryFeatureFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<ExternalMemoryFeatureFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(ExternalMemoryFeatureFlagBits::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBits::eExportable) | VkFlags(ExternalMemoryFeatureFlagBits::eImportable)
+    };
+  };
+
+  using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags;
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ExternalMemoryFeatureFlagBits::eDedicatedOnly ) result += "DedicatedOnly | ";
+    if ( value & ExternalMemoryFeatureFlagBits::eExportable ) result += "Exportable | ";
+    if ( value & ExternalMemoryFeatureFlagBits::eImportable ) result += "Importable";
+  }
+
+  enum class ExternalMemoryFeatureFlagBitsNV
+  {
+    eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV,
+    eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV,
+    eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlagBitsNV value )
+  {
+    switch ( value )
+    {
+      case ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly : return "DedicatedOnly";
+      case ExternalMemoryFeatureFlagBitsNV::eExportable : return "Exportable";
+      case ExternalMemoryFeatureFlagBitsNV::eImportable : return "Importable";
+      default: return "invalid";
+    }
+  }
+
+  using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV, VkExternalMemoryFeatureFlagsNV>;
+
+  VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
+  {
+    return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits )
+  {
+    return ~( ExternalMemoryFeatureFlagsNV( bits ) );
+  }
+
+  template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsNV>
+  {
+    enum
+    {
+      allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlagsNV value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly ) result += "DedicatedOnly | ";
+    if ( value & ExternalMemoryFeatureFlagBitsNV::eExportable ) result += "Exportable | ";
+    if ( value & ExternalMemoryFeatureFlagBitsNV::eImportable ) result += "Importable";
+  }
+
+  enum class ExternalMemoryHandleTypeFlagBits
+  {
+    eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+    eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+    eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+    eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
+    eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
+    eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
+    eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
+    eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
+    eAndroidHardwareBufferANDROID = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
+    eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
+    eHostMappedForeignMemoryEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT,
+    eOpaqueFdKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
+    eOpaqueWin32KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
+    eOpaqueWin32KmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
+    eD3D11TextureKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR,
+    eD3D11TextureKmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR,
+    eD3D12HeapKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR,
+    eD3D12ResourceKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlagBits value )
+  {
+    switch ( value )
+    {
+      case ExternalMemoryHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd";
+      case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32";
+      case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt : return "OpaqueWin32Kmt";
+      case ExternalMemoryHandleTypeFlagBits::eD3D11Texture : return "D3D11Texture";
+      case ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt : return "D3D11TextureKmt";
+      case ExternalMemoryHandleTypeFlagBits::eD3D12Heap : return "D3D12Heap";
+      case ExternalMemoryHandleTypeFlagBits::eD3D12Resource : return "D3D12Resource";
+      case ExternalMemoryHandleTypeFlagBits::eDmaBufEXT : return "DmaBufEXT";
+      case ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID : return "AndroidHardwareBufferANDROID";
+      case ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT : return "HostAllocationEXT";
+      case ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT : return "HostMappedForeignMemoryEXT";
+      default: return "invalid";
+    }
+  }
+
+  using ExternalMemoryHandleTypeFlags = Flags<ExternalMemoryHandleTypeFlagBits, VkExternalMemoryHandleTypeFlags>;
+
+  VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator|( ExternalMemoryHandleTypeFlagBits bit0, ExternalMemoryHandleTypeFlagBits bit1 )
+  {
+    return ExternalMemoryHandleTypeFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator~( ExternalMemoryHandleTypeFlagBits bits )
+  {
+    return ~( ExternalMemoryHandleTypeFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Resource) | VkFlags(ExternalMemoryHandleTypeFlagBits::eDmaBufEXT) | VkFlags(ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID) | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT) | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT)
+    };
+  };
+
+  using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags;
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) result += "OpaqueFd | ";
+    if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 ) result += "OpaqueWin32 | ";
+    if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt ) result += "OpaqueWin32Kmt | ";
+    if ( value & ExternalMemoryHandleTypeFlagBits::eD3D11Texture ) result += "D3D11Texture | ";
+    if ( value & ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt ) result += "D3D11TextureKmt | ";
+    if ( value & ExternalMemoryHandleTypeFlagBits::eD3D12Heap ) result += "D3D12Heap | ";
+    if ( value & ExternalMemoryHandleTypeFlagBits::eD3D12Resource ) result += "D3D12Resource | ";
+    if ( value & ExternalMemoryHandleTypeFlagBits::eDmaBufEXT ) result += "DmaBufEXT | ";
+    if ( value & ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID ) result += "AndroidHardwareBufferANDROID | ";
+    if ( value & ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT ) result += "HostAllocationEXT | ";
+    if ( value & ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT ) result += "HostMappedForeignMemoryEXT";
+  }
+
+  enum class ExternalMemoryHandleTypeFlagBitsNV
+  {
+    eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV,
+    eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV,
+    eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV,
+    eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlagBitsNV value )
+  {
+    switch ( value )
+    {
+      case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 : return "OpaqueWin32";
+      case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt : return "OpaqueWin32Kmt";
+      case ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image : return "D3D11Image";
+      case ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt : return "D3D11ImageKmt";
+      default: return "invalid";
+    }
+  }
+
+  using ExternalMemoryHandleTypeFlagsNV = Flags<ExternalMemoryHandleTypeFlagBitsNV, VkExternalMemoryHandleTypeFlagsNV>;
+
+  VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
+  {
+    return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits )
+  {
+    return ~( ExternalMemoryHandleTypeFlagsNV( bits ) );
+  }
+
+  template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsNV>
+  {
+    enum
+    {
+      allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlagsNV value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 ) result += "OpaqueWin32 | ";
+    if ( value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt ) result += "OpaqueWin32Kmt | ";
+    if ( value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image ) result += "D3D11Image | ";
+    if ( value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt ) result += "D3D11ImageKmt";
+  }
+
+  enum class ExternalSemaphoreFeatureFlagBits
+  {
+    eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
+    eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT,
+    eExportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR,
+    eImportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreFeatureFlagBits value )
+  {
+    switch ( value )
+    {
+      case ExternalSemaphoreFeatureFlagBits::eExportable : return "Exportable";
+      case ExternalSemaphoreFeatureFlagBits::eImportable : return "Importable";
+      default: return "invalid";
+    }
+  }
+
+  using ExternalSemaphoreFeatureFlags = Flags<ExternalSemaphoreFeatureFlagBits, VkExternalSemaphoreFeatureFlags>;
+
+  VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator|( ExternalSemaphoreFeatureFlagBits bit0, ExternalSemaphoreFeatureFlagBits bit1 )
+  {
+    return ExternalSemaphoreFeatureFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator~( ExternalSemaphoreFeatureFlagBits bits )
+  {
+    return ~( ExternalSemaphoreFeatureFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<ExternalSemaphoreFeatureFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(ExternalSemaphoreFeatureFlagBits::eExportable) | VkFlags(ExternalSemaphoreFeatureFlagBits::eImportable)
+    };
+  };
+
+  using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags;
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreFeatureFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ExternalSemaphoreFeatureFlagBits::eExportable ) result += "Exportable | ";
+    if ( value & ExternalSemaphoreFeatureFlagBits::eImportable ) result += "Importable";
+  }
+
+  enum class ExternalSemaphoreHandleTypeFlagBits
+  {
+    eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
+    eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+    eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+    eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
+    eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
+    eOpaqueFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
+    eOpaqueWin32KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
+    eOpaqueWin32KmtKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
+    eD3D12FenceKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR,
+    eSyncFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreHandleTypeFlagBits value )
+  {
+    switch ( value )
+    {
+      case ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd";
+      case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32";
+      case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt : return "OpaqueWin32Kmt";
+      case ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence : return "D3D12Fence";
+      case ExternalSemaphoreHandleTypeFlagBits::eSyncFd : return "SyncFd";
+      default: return "invalid";
+    }
+  }
+
+  using ExternalSemaphoreHandleTypeFlags = Flags<ExternalSemaphoreHandleTypeFlagBits, VkExternalSemaphoreHandleTypeFlags>;
+
+  VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator|( ExternalSemaphoreHandleTypeFlagBits bit0, ExternalSemaphoreHandleTypeFlagBits bit1 )
+  {
+    return ExternalSemaphoreHandleTypeFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator~( ExternalSemaphoreHandleTypeFlagBits bits )
+  {
+    return ~( ExternalSemaphoreHandleTypeFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<ExternalSemaphoreHandleTypeFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eSyncFd)
+    };
+  };
+
+  using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags;
+
+  VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreHandleTypeFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) result += "OpaqueFd | ";
+    if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 ) result += "OpaqueWin32 | ";
+    if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt ) result += "OpaqueWin32Kmt | ";
+    if ( value & ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence ) result += "D3D12Fence | ";
+    if ( value & ExternalSemaphoreHandleTypeFlagBits::eSyncFd ) result += "SyncFd";
+  }
+
+  enum class FenceCreateFlagBits
+  {
+    eSignaled = VK_FENCE_CREATE_SIGNALED_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( FenceCreateFlagBits value )
+  {
+    switch ( value )
+    {
+      case FenceCreateFlagBits::eSignaled : return "Signaled";
+      default: return "invalid";
+    }
+  }
+
+  using FenceCreateFlags = Flags<FenceCreateFlagBits, VkFenceCreateFlags>;
+
+  VULKAN_HPP_INLINE FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
+  {
+    return FenceCreateFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE FenceCreateFlags operator~( FenceCreateFlagBits bits )
+  {
+    return ~( FenceCreateFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<FenceCreateFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(FenceCreateFlagBits::eSignaled)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( FenceCreateFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & FenceCreateFlagBits::eSignaled ) result += "Signaled";
+  }
+
+  enum class FenceImportFlagBits
+  {
+    eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT,
+    eTemporaryKHR = VK_FENCE_IMPORT_TEMPORARY_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( FenceImportFlagBits value )
+  {
+    switch ( value )
+    {
+      case FenceImportFlagBits::eTemporary : return "Temporary";
+      default: return "invalid";
+    }
+  }
+
+  using FenceImportFlags = Flags<FenceImportFlagBits, VkFenceImportFlags>;
+
+  VULKAN_HPP_INLINE FenceImportFlags operator|( FenceImportFlagBits bit0, FenceImportFlagBits bit1 )
+  {
+    return FenceImportFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE FenceImportFlags operator~( FenceImportFlagBits bits )
+  {
+    return ~( FenceImportFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<FenceImportFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(FenceImportFlagBits::eTemporary)
+    };
+  };
+
+  using FenceImportFlagsKHR = FenceImportFlags;
+
+  VULKAN_HPP_INLINE std::string to_string( FenceImportFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & FenceImportFlagBits::eTemporary ) result += "Temporary";
+  }
+
+  enum class FormatFeatureFlagBits
+  {
+    eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
+    eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
+    eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,
+    eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT,
+    eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT,
+    eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT,
+    eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
+    eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
+    eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,
+    eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
+    eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT,
+    eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT,
+    eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
+    eTransferSrc = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
+    eTransferDst = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
+    eMidpointChromaSamples = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
+    eSampledImageYcbcrConversionLinearFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
+    eSampledImageYcbcrConversionSeparateReconstructionFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
+    eSampledImageYcbcrConversionChromaReconstructionExplicit = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
+    eSampledImageYcbcrConversionChromaReconstructionExplicitForceable = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
+    eDisjoint = VK_FORMAT_FEATURE_DISJOINT_BIT,
+    eCositedChromaSamples = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
+    eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
+    eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT,
+    eFragmentDensityMapEXT = VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT,
+    eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR,
+    eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR,
+    eMidpointChromaSamplesKHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR,
+    eSampledImageYcbcrConversionLinearFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR,
+    eSampledImageYcbcrConversionSeparateReconstructionFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR,
+    eSampledImageYcbcrConversionChromaReconstructionExplicitKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR,
+    eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR,
+    eDisjointKHR = VK_FORMAT_FEATURE_DISJOINT_BIT_KHR,
+    eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlagBits value )
+  {
+    switch ( value )
+    {
+      case FormatFeatureFlagBits::eSampledImage : return "SampledImage";
+      case FormatFeatureFlagBits::eStorageImage : return "StorageImage";
+      case FormatFeatureFlagBits::eStorageImageAtomic : return "StorageImageAtomic";
+      case FormatFeatureFlagBits::eUniformTexelBuffer : return "UniformTexelBuffer";
+      case FormatFeatureFlagBits::eStorageTexelBuffer : return "StorageTexelBuffer";
+      case FormatFeatureFlagBits::eStorageTexelBufferAtomic : return "StorageTexelBufferAtomic";
+      case FormatFeatureFlagBits::eVertexBuffer : return "VertexBuffer";
+      case FormatFeatureFlagBits::eColorAttachment : return "ColorAttachment";
+      case FormatFeatureFlagBits::eColorAttachmentBlend : return "ColorAttachmentBlend";
+      case FormatFeatureFlagBits::eDepthStencilAttachment : return "DepthStencilAttachment";
+      case FormatFeatureFlagBits::eBlitSrc : return "BlitSrc";
+      case FormatFeatureFlagBits::eBlitDst : return "BlitDst";
+      case FormatFeatureFlagBits::eSampledImageFilterLinear : return "SampledImageFilterLinear";
+      case FormatFeatureFlagBits::eTransferSrc : return "TransferSrc";
+      case FormatFeatureFlagBits::eTransferDst : return "TransferDst";
+      case FormatFeatureFlagBits::eMidpointChromaSamples : return "MidpointChromaSamples";
+      case FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter : return "SampledImageYcbcrConversionLinearFilter";
+      case FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter : return "SampledImageYcbcrConversionSeparateReconstructionFilter";
+      case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit : return "SampledImageYcbcrConversionChromaReconstructionExplicit";
+      case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable : return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable";
+      case FormatFeatureFlagBits::eDisjoint : return "Disjoint";
+      case FormatFeatureFlagBits::eCositedChromaSamples : return "CositedChromaSamples";
+      case FormatFeatureFlagBits::eSampledImageFilterCubicIMG : return "SampledImageFilterCubicIMG";
+      case FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT : return "SampledImageFilterMinmaxEXT";
+      case FormatFeatureFlagBits::eFragmentDensityMapEXT : return "FragmentDensityMapEXT";
+      default: return "invalid";
+    }
+  }
+
+  using FormatFeatureFlags = Flags<FormatFeatureFlagBits, VkFormatFeatureFlags>;
+
+  VULKAN_HPP_INLINE FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
+  {
+    return FormatFeatureFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE FormatFeatureFlags operator~( FormatFeatureFlagBits bits )
+  {
+    return ~( FormatFeatureFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<FormatFeatureFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eTransferSrc) | VkFlags(FormatFeatureFlagBits::eTransferDst) | VkFlags(FormatFeatureFlagBits::eMidpointChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable) | VkFlags(FormatFeatureFlagBits::eDisjoint) | VkFlags(FormatFeatureFlagBits::eCositedChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) | VkFlags(FormatFeatureFlagBits::eFragmentDensityMapEXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & FormatFeatureFlagBits::eSampledImage ) result += "SampledImage | ";
+    if ( value & FormatFeatureFlagBits::eStorageImage ) result += "StorageImage | ";
+    if ( value & FormatFeatureFlagBits::eStorageImageAtomic ) result += "StorageImageAtomic | ";
+    if ( value & FormatFeatureFlagBits::eUniformTexelBuffer ) result += "UniformTexelBuffer | ";
+    if ( value & FormatFeatureFlagBits::eStorageTexelBuffer ) result += "StorageTexelBuffer | ";
+    if ( value & FormatFeatureFlagBits::eStorageTexelBufferAtomic ) result += "StorageTexelBufferAtomic | ";
+    if ( value & FormatFeatureFlagBits::eVertexBuffer ) result += "VertexBuffer | ";
+    if ( value & FormatFeatureFlagBits::eColorAttachment ) result += "ColorAttachment | ";
+    if ( value & FormatFeatureFlagBits::eColorAttachmentBlend ) result += "ColorAttachmentBlend | ";
+    if ( value & FormatFeatureFlagBits::eDepthStencilAttachment ) result += "DepthStencilAttachment | ";
+    if ( value & FormatFeatureFlagBits::eBlitSrc ) result += "BlitSrc | ";
+    if ( value & FormatFeatureFlagBits::eBlitDst ) result += "BlitDst | ";
+    if ( value & FormatFeatureFlagBits::eSampledImageFilterLinear ) result += "SampledImageFilterLinear | ";
+    if ( value & FormatFeatureFlagBits::eTransferSrc ) result += "TransferSrc | ";
+    if ( value & FormatFeatureFlagBits::eTransferDst ) result += "TransferDst | ";
+    if ( value & FormatFeatureFlagBits::eMidpointChromaSamples ) result += "MidpointChromaSamples | ";
+    if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter ) result += "SampledImageYcbcrConversionLinearFilter | ";
+    if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter ) result += "SampledImageYcbcrConversionSeparateReconstructionFilter | ";
+    if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit ) result += "SampledImageYcbcrConversionChromaReconstructionExplicit | ";
+    if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable ) result += "SampledImageYcbcrConversionChromaReconstructionExplicitForceable | ";
+    if ( value & FormatFeatureFlagBits::eDisjoint ) result += "Disjoint | ";
+    if ( value & FormatFeatureFlagBits::eCositedChromaSamples ) result += "CositedChromaSamples | ";
+    if ( value & FormatFeatureFlagBits::eSampledImageFilterCubicIMG ) result += "SampledImageFilterCubicIMG | ";
+    if ( value & FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT ) result += "SampledImageFilterMinmaxEXT | ";
+    if ( value & FormatFeatureFlagBits::eFragmentDensityMapEXT ) result += "FragmentDensityMapEXT";
+  }
+
+  enum class FramebufferCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits, VkFramebufferCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class GeometryFlagBitsNV
+  {
+    eOpaque = VK_GEOMETRY_OPAQUE_BIT_NV,
+    eNoDuplicateAnyHitInvocation = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( GeometryFlagBitsNV value )
+  {
+    switch ( value )
+    {
+      case GeometryFlagBitsNV::eOpaque : return "Opaque";
+      case GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation : return "NoDuplicateAnyHitInvocation";
+      default: return "invalid";
+    }
+  }
+
+  using GeometryFlagsNV = Flags<GeometryFlagBitsNV, VkGeometryFlagsNV>;
+
+  VULKAN_HPP_INLINE GeometryFlagsNV operator|( GeometryFlagBitsNV bit0, GeometryFlagBitsNV bit1 )
+  {
+    return GeometryFlagsNV( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE GeometryFlagsNV operator~( GeometryFlagBitsNV bits )
+  {
+    return ~( GeometryFlagsNV( bits ) );
+  }
+
+  template <> struct FlagTraits<GeometryFlagBitsNV>
+  {
+    enum
+    {
+      allFlags = VkFlags(GeometryFlagBitsNV::eOpaque) | VkFlags(GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( GeometryFlagsNV value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & GeometryFlagBitsNV::eOpaque ) result += "Opaque | ";
+    if ( value & GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation ) result += "NoDuplicateAnyHitInvocation";
+  }
+
+  enum class GeometryInstanceFlagBitsNV
+  {
+    eTriangleCullDisable = VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV,
+    eTriangleFrontCounterclockwise = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV,
+    eForceOpaque = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV,
+    eForceNoOpaque = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( GeometryInstanceFlagBitsNV value )
+  {
+    switch ( value )
+    {
+      case GeometryInstanceFlagBitsNV::eTriangleCullDisable : return "TriangleCullDisable";
+      case GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise : return "TriangleFrontCounterclockwise";
+      case GeometryInstanceFlagBitsNV::eForceOpaque : return "ForceOpaque";
+      case GeometryInstanceFlagBitsNV::eForceNoOpaque : return "ForceNoOpaque";
+      default: return "invalid";
+    }
+  }
+
+  using GeometryInstanceFlagsNV = Flags<GeometryInstanceFlagBitsNV, VkGeometryInstanceFlagsNV>;
+
+  VULKAN_HPP_INLINE GeometryInstanceFlagsNV operator|( GeometryInstanceFlagBitsNV bit0, GeometryInstanceFlagBitsNV bit1 )
+  {
+    return GeometryInstanceFlagsNV( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE GeometryInstanceFlagsNV operator~( GeometryInstanceFlagBitsNV bits )
+  {
+    return ~( GeometryInstanceFlagsNV( bits ) );
+  }
+
+  template <> struct FlagTraits<GeometryInstanceFlagBitsNV>
+  {
+    enum
+    {
+      allFlags = VkFlags(GeometryInstanceFlagBitsNV::eTriangleCullDisable) | VkFlags(GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise) | VkFlags(GeometryInstanceFlagBitsNV::eForceOpaque) | VkFlags(GeometryInstanceFlagBitsNV::eForceNoOpaque)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( GeometryInstanceFlagsNV value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & GeometryInstanceFlagBitsNV::eTriangleCullDisable ) result += "TriangleCullDisable | ";
+    if ( value & GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise ) result += "TriangleFrontCounterclockwise | ";
+    if ( value & GeometryInstanceFlagBitsNV::eForceOpaque ) result += "ForceOpaque | ";
+    if ( value & GeometryInstanceFlagBitsNV::eForceNoOpaque ) result += "ForceNoOpaque";
+  }
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+  enum class IOSSurfaceCreateFlagBitsMVK
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( IOSSurfaceCreateFlagBitsMVK )
+  {
+    return "(void)";
+  }
+
+  using IOSSurfaceCreateFlagsMVK = Flags<IOSSurfaceCreateFlagBitsMVK, VkIOSSurfaceCreateFlagsMVK>;
+
+  VULKAN_HPP_INLINE std::string to_string( IOSSurfaceCreateFlagsMVK  )
+  {
+    return "{}";
+  }
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+  enum class ImageAspectFlagBits
+  {
+    eColor = VK_IMAGE_ASPECT_COLOR_BIT,
+    eDepth = VK_IMAGE_ASPECT_DEPTH_BIT,
+    eStencil = VK_IMAGE_ASPECT_STENCIL_BIT,
+    eMetadata = VK_IMAGE_ASPECT_METADATA_BIT,
+    ePlane0 = VK_IMAGE_ASPECT_PLANE_0_BIT,
+    ePlane1 = VK_IMAGE_ASPECT_PLANE_1_BIT,
+    ePlane2 = VK_IMAGE_ASPECT_PLANE_2_BIT,
+    eMemoryPlane0EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT,
+    eMemoryPlane1EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT,
+    eMemoryPlane2EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT,
+    eMemoryPlane3EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT,
+    ePlane0KHR = VK_IMAGE_ASPECT_PLANE_0_BIT_KHR,
+    ePlane1KHR = VK_IMAGE_ASPECT_PLANE_1_BIT_KHR,
+    ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageAspectFlagBits value )
+  {
+    switch ( value )
+    {
+      case ImageAspectFlagBits::eColor : return "Color";
+      case ImageAspectFlagBits::eDepth : return "Depth";
+      case ImageAspectFlagBits::eStencil : return "Stencil";
+      case ImageAspectFlagBits::eMetadata : return "Metadata";
+      case ImageAspectFlagBits::ePlane0 : return "Plane0";
+      case ImageAspectFlagBits::ePlane1 : return "Plane1";
+      case ImageAspectFlagBits::ePlane2 : return "Plane2";
+      case ImageAspectFlagBits::eMemoryPlane0EXT : return "MemoryPlane0EXT";
+      case ImageAspectFlagBits::eMemoryPlane1EXT : return "MemoryPlane1EXT";
+      case ImageAspectFlagBits::eMemoryPlane2EXT : return "MemoryPlane2EXT";
+      case ImageAspectFlagBits::eMemoryPlane3EXT : return "MemoryPlane3EXT";
+      default: return "invalid";
+    }
+  }
+
+  using ImageAspectFlags = Flags<ImageAspectFlagBits, VkImageAspectFlags>;
+
+  VULKAN_HPP_INLINE ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
+  {
+    return ImageAspectFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ImageAspectFlags operator~( ImageAspectFlagBits bits )
+  {
+    return ~( ImageAspectFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<ImageAspectFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(ImageAspectFlagBits::eColor) | VkFlags(ImageAspectFlagBits::eDepth) | VkFlags(ImageAspectFlagBits::eStencil) | VkFlags(ImageAspectFlagBits::eMetadata) | VkFlags(ImageAspectFlagBits::ePlane0) | VkFlags(ImageAspectFlagBits::ePlane1) | VkFlags(ImageAspectFlagBits::ePlane2) | VkFlags(ImageAspectFlagBits::eMemoryPlane0EXT) | VkFlags(ImageAspectFlagBits::eMemoryPlane1EXT) | VkFlags(ImageAspectFlagBits::eMemoryPlane2EXT) | VkFlags(ImageAspectFlagBits::eMemoryPlane3EXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageAspectFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ImageAspectFlagBits::eColor ) result += "Color | ";
+    if ( value & ImageAspectFlagBits::eDepth ) result += "Depth | ";
+    if ( value & ImageAspectFlagBits::eStencil ) result += "Stencil | ";
+    if ( value & ImageAspectFlagBits::eMetadata ) result += "Metadata | ";
+    if ( value & ImageAspectFlagBits::ePlane0 ) result += "Plane0 | ";
+    if ( value & ImageAspectFlagBits::ePlane1 ) result += "Plane1 | ";
+    if ( value & ImageAspectFlagBits::ePlane2 ) result += "Plane2 | ";
+    if ( value & ImageAspectFlagBits::eMemoryPlane0EXT ) result += "MemoryPlane0EXT | ";
+    if ( value & ImageAspectFlagBits::eMemoryPlane1EXT ) result += "MemoryPlane1EXT | ";
+    if ( value & ImageAspectFlagBits::eMemoryPlane2EXT ) result += "MemoryPlane2EXT | ";
+    if ( value & ImageAspectFlagBits::eMemoryPlane3EXT ) result += "MemoryPlane3EXT";
+  }
+
+  enum class ImageCreateFlagBits
+  {
+    eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT,
+    eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,
+    eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
+    eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
+    eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
+    eAlias = VK_IMAGE_CREATE_ALIAS_BIT,
+    eSplitInstanceBindRegions = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
+    e2DArrayCompatible = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
+    eBlockTexelViewCompatible = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
+    eExtendedUsage = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
+    eProtected = VK_IMAGE_CREATE_PROTECTED_BIT,
+    eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT,
+    eCornerSampledNV = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV,
+    eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT,
+    eSubsampledEXT = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT,
+    eSplitInstanceBindRegionsKHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR,
+    e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR,
+    eBlockTexelViewCompatibleKHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR,
+    eExtendedUsageKHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR,
+    eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT_KHR,
+    eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageCreateFlagBits value )
+  {
+    switch ( value )
+    {
+      case ImageCreateFlagBits::eSparseBinding : return "SparseBinding";
+      case ImageCreateFlagBits::eSparseResidency : return "SparseResidency";
+      case ImageCreateFlagBits::eSparseAliased : return "SparseAliased";
+      case ImageCreateFlagBits::eMutableFormat : return "MutableFormat";
+      case ImageCreateFlagBits::eCubeCompatible : return "CubeCompatible";
+      case ImageCreateFlagBits::eAlias : return "Alias";
+      case ImageCreateFlagBits::eSplitInstanceBindRegions : return "SplitInstanceBindRegions";
+      case ImageCreateFlagBits::e2DArrayCompatible : return "2DArrayCompatible";
+      case ImageCreateFlagBits::eBlockTexelViewCompatible : return "BlockTexelViewCompatible";
+      case ImageCreateFlagBits::eExtendedUsage : return "ExtendedUsage";
+      case ImageCreateFlagBits::eProtected : return "Protected";
+      case ImageCreateFlagBits::eDisjoint : return "Disjoint";
+      case ImageCreateFlagBits::eCornerSampledNV : return "CornerSampledNV";
+      case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT : return "SampleLocationsCompatibleDepthEXT";
+      case ImageCreateFlagBits::eSubsampledEXT : return "SubsampledEXT";
+      default: return "invalid";
+    }
+  }
+
+  using ImageCreateFlags = Flags<ImageCreateFlagBits, VkImageCreateFlags>;
+
+  VULKAN_HPP_INLINE ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
+  {
+    return ImageCreateFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ImageCreateFlags operator~( ImageCreateFlagBits bits )
+  {
+    return ~( ImageCreateFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<ImageCreateFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eAlias) | VkFlags(ImageCreateFlagBits::eSplitInstanceBindRegions) | VkFlags(ImageCreateFlagBits::e2DArrayCompatible) | VkFlags(ImageCreateFlagBits::eBlockTexelViewCompatible) | VkFlags(ImageCreateFlagBits::eExtendedUsage) | VkFlags(ImageCreateFlagBits::eProtected) | VkFlags(ImageCreateFlagBits::eDisjoint) | VkFlags(ImageCreateFlagBits::eCornerSampledNV) | VkFlags(ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) | VkFlags(ImageCreateFlagBits::eSubsampledEXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageCreateFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ImageCreateFlagBits::eSparseBinding ) result += "SparseBinding | ";
+    if ( value & ImageCreateFlagBits::eSparseResidency ) result += "SparseResidency | ";
+    if ( value & ImageCreateFlagBits::eSparseAliased ) result += "SparseAliased | ";
+    if ( value & ImageCreateFlagBits::eMutableFormat ) result += "MutableFormat | ";
+    if ( value & ImageCreateFlagBits::eCubeCompatible ) result += "CubeCompatible | ";
+    if ( value & ImageCreateFlagBits::eAlias ) result += "Alias | ";
+    if ( value & ImageCreateFlagBits::eSplitInstanceBindRegions ) result += "SplitInstanceBindRegions | ";
+    if ( value & ImageCreateFlagBits::e2DArrayCompatible ) result += "2DArrayCompatible | ";
+    if ( value & ImageCreateFlagBits::eBlockTexelViewCompatible ) result += "BlockTexelViewCompatible | ";
+    if ( value & ImageCreateFlagBits::eExtendedUsage ) result += "ExtendedUsage | ";
+    if ( value & ImageCreateFlagBits::eProtected ) result += "Protected | ";
+    if ( value & ImageCreateFlagBits::eDisjoint ) result += "Disjoint | ";
+    if ( value & ImageCreateFlagBits::eCornerSampledNV ) result += "CornerSampledNV | ";
+    if ( value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT ) result += "SampleLocationsCompatibleDepthEXT | ";
+    if ( value & ImageCreateFlagBits::eSubsampledEXT ) result += "SubsampledEXT";
+  }
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+  enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( ImagePipeSurfaceCreateFlagBitsFUCHSIA )
+  {
+    return "(void)";
+  }
+
+  using ImagePipeSurfaceCreateFlagsFUCHSIA = Flags<ImagePipeSurfaceCreateFlagBitsFUCHSIA, VkImagePipeSurfaceCreateFlagsFUCHSIA>;
+
+  VULKAN_HPP_INLINE std::string to_string( ImagePipeSurfaceCreateFlagsFUCHSIA  )
+  {
+    return "{}";
+  }
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+  enum class ImageUsageFlagBits
+  {
+    eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+    eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
+    eSampled = VK_IMAGE_USAGE_SAMPLED_BIT,
+    eStorage = VK_IMAGE_USAGE_STORAGE_BIT,
+    eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+    eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
+    eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
+    eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
+    eShadingRateImageNV = VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV,
+    eFragmentDensityMapEXT = VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageUsageFlagBits value )
+  {
+    switch ( value )
+    {
+      case ImageUsageFlagBits::eTransferSrc : return "TransferSrc";
+      case ImageUsageFlagBits::eTransferDst : return "TransferDst";
+      case ImageUsageFlagBits::eSampled : return "Sampled";
+      case ImageUsageFlagBits::eStorage : return "Storage";
+      case ImageUsageFlagBits::eColorAttachment : return "ColorAttachment";
+      case ImageUsageFlagBits::eDepthStencilAttachment : return "DepthStencilAttachment";
+      case ImageUsageFlagBits::eTransientAttachment : return "TransientAttachment";
+      case ImageUsageFlagBits::eInputAttachment : return "InputAttachment";
+      case ImageUsageFlagBits::eShadingRateImageNV : return "ShadingRateImageNV";
+      case ImageUsageFlagBits::eFragmentDensityMapEXT : return "FragmentDensityMapEXT";
+      default: return "invalid";
+    }
+  }
+
+  using ImageUsageFlags = Flags<ImageUsageFlagBits, VkImageUsageFlags>;
+
+  VULKAN_HPP_INLINE ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
+  {
+    return ImageUsageFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ImageUsageFlags operator~( ImageUsageFlagBits bits )
+  {
+    return ~( ImageUsageFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<ImageUsageFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment) | VkFlags(ImageUsageFlagBits::eShadingRateImageNV) | VkFlags(ImageUsageFlagBits::eFragmentDensityMapEXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageUsageFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ImageUsageFlagBits::eTransferSrc ) result += "TransferSrc | ";
+    if ( value & ImageUsageFlagBits::eTransferDst ) result += "TransferDst | ";
+    if ( value & ImageUsageFlagBits::eSampled ) result += "Sampled | ";
+    if ( value & ImageUsageFlagBits::eStorage ) result += "Storage | ";
+    if ( value & ImageUsageFlagBits::eColorAttachment ) result += "ColorAttachment | ";
+    if ( value & ImageUsageFlagBits::eDepthStencilAttachment ) result += "DepthStencilAttachment | ";
+    if ( value & ImageUsageFlagBits::eTransientAttachment ) result += "TransientAttachment | ";
+    if ( value & ImageUsageFlagBits::eInputAttachment ) result += "InputAttachment | ";
+    if ( value & ImageUsageFlagBits::eShadingRateImageNV ) result += "ShadingRateImageNV | ";
+    if ( value & ImageUsageFlagBits::eFragmentDensityMapEXT ) result += "FragmentDensityMapEXT";
+  }
+
+  enum class ImageViewCreateFlagBits
+  {
+    eFragmentDensityMapDynamicEXT = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlagBits value )
+  {
+    switch ( value )
+    {
+      case ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT : return "FragmentDensityMapDynamicEXT";
+      default: return "invalid";
+    }
+  }
+
+  using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits, VkImageViewCreateFlags>;
+
+  VULKAN_HPP_INLINE ImageViewCreateFlags operator|( ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1 )
+  {
+    return ImageViewCreateFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ImageViewCreateFlags operator~( ImageViewCreateFlagBits bits )
+  {
+    return ~( ImageViewCreateFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<ImageViewCreateFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT ) result += "FragmentDensityMapDynamicEXT";
+  }
+
+  enum class IndirectCommandsLayoutUsageFlagBitsNVX
+  {
+    eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX,
+    eSparseSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX,
+    eEmptyExecutions = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX,
+    eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagBitsNVX value )
+  {
+    switch ( value )
+    {
+      case IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences : return "UnorderedSequences";
+      case IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences : return "SparseSequences";
+      case IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions : return "EmptyExecutions";
+      case IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences : return "IndexedSequences";
+      default: return "invalid";
+    }
+  }
+
+  using IndirectCommandsLayoutUsageFlagsNVX = Flags<IndirectCommandsLayoutUsageFlagBitsNVX, VkIndirectCommandsLayoutUsageFlagsNVX>;
+
+  VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 )
+  {
+    return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits )
+  {
+    return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) );
+  }
+
+  template <> struct FlagTraits<IndirectCommandsLayoutUsageFlagBitsNVX>
+  {
+    enum
+    {
+      allFlags = VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagsNVX value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences ) result += "UnorderedSequences | ";
+    if ( value & IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences ) result += "SparseSequences | ";
+    if ( value & IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions ) result += "EmptyExecutions | ";
+    if ( value & IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences ) result += "IndexedSequences";
+  }
+
+  enum class InstanceCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using InstanceCreateFlags = Flags<InstanceCreateFlagBits, VkInstanceCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlags  )
+  {
+    return "{}";
+  }
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+  enum class MacOSSurfaceCreateFlagBitsMVK
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( MacOSSurfaceCreateFlagBitsMVK )
+  {
+    return "(void)";
+  }
+
+  using MacOSSurfaceCreateFlagsMVK = Flags<MacOSSurfaceCreateFlagBitsMVK, VkMacOSSurfaceCreateFlagsMVK>;
+
+  VULKAN_HPP_INLINE std::string to_string( MacOSSurfaceCreateFlagsMVK  )
+  {
+    return "{}";
+  }
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
+  enum class MemoryAllocateFlagBits
+  {
+    eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
+    eDeviceMaskKHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( MemoryAllocateFlagBits value )
+  {
+    switch ( value )
+    {
+      case MemoryAllocateFlagBits::eDeviceMask : return "DeviceMask";
+      default: return "invalid";
+    }
+  }
+
+  using MemoryAllocateFlags = Flags<MemoryAllocateFlagBits, VkMemoryAllocateFlags>;
+
+  VULKAN_HPP_INLINE MemoryAllocateFlags operator|( MemoryAllocateFlagBits bit0, MemoryAllocateFlagBits bit1 )
+  {
+    return MemoryAllocateFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE MemoryAllocateFlags operator~( MemoryAllocateFlagBits bits )
+  {
+    return ~( MemoryAllocateFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<MemoryAllocateFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(MemoryAllocateFlagBits::eDeviceMask)
+    };
+  };
+
+  using MemoryAllocateFlagsKHR = MemoryAllocateFlags;
+
+  VULKAN_HPP_INLINE std::string to_string( MemoryAllocateFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & MemoryAllocateFlagBits::eDeviceMask ) result += "DeviceMask";
+  }
+
+  enum class MemoryHeapFlagBits
+  {
+    eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
+    eMultiInstance = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
+    eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( MemoryHeapFlagBits value )
+  {
+    switch ( value )
+    {
+      case MemoryHeapFlagBits::eDeviceLocal : return "DeviceLocal";
+      case MemoryHeapFlagBits::eMultiInstance : return "MultiInstance";
+      default: return "invalid";
+    }
+  }
+
+  using MemoryHeapFlags = Flags<MemoryHeapFlagBits, VkMemoryHeapFlags>;
+
+  VULKAN_HPP_INLINE MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
+  {
+    return MemoryHeapFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE MemoryHeapFlags operator~( MemoryHeapFlagBits bits )
+  {
+    return ~( MemoryHeapFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<MemoryHeapFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(MemoryHeapFlagBits::eDeviceLocal) | VkFlags(MemoryHeapFlagBits::eMultiInstance)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( MemoryHeapFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & MemoryHeapFlagBits::eDeviceLocal ) result += "DeviceLocal | ";
+    if ( value & MemoryHeapFlagBits::eMultiInstance ) result += "MultiInstance";
+  }
+
+  enum class MemoryMapFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( MemoryMapFlagBits )
+  {
+    return "(void)";
+  }
+
+  using MemoryMapFlags = Flags<MemoryMapFlagBits, VkMemoryMapFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags  )
+  {
+    return "{}";
+  }
+
+  enum class MemoryPropertyFlagBits
+  {
+    eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+    eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+    eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+    eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
+    eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT,
+    eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( MemoryPropertyFlagBits value )
+  {
+    switch ( value )
+    {
+      case MemoryPropertyFlagBits::eDeviceLocal : return "DeviceLocal";
+      case MemoryPropertyFlagBits::eHostVisible : return "HostVisible";
+      case MemoryPropertyFlagBits::eHostCoherent : return "HostCoherent";
+      case MemoryPropertyFlagBits::eHostCached : return "HostCached";
+      case MemoryPropertyFlagBits::eLazilyAllocated : return "LazilyAllocated";
+      case MemoryPropertyFlagBits::eProtected : return "Protected";
+      default: return "invalid";
+    }
+  }
+
+  using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits, VkMemoryPropertyFlags>;
+
+  VULKAN_HPP_INLINE MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
+  {
+    return MemoryPropertyFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits )
+  {
+    return ~( MemoryPropertyFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<MemoryPropertyFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated) | VkFlags(MemoryPropertyFlagBits::eProtected)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( MemoryPropertyFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & MemoryPropertyFlagBits::eDeviceLocal ) result += "DeviceLocal | ";
+    if ( value & MemoryPropertyFlagBits::eHostVisible ) result += "HostVisible | ";
+    if ( value & MemoryPropertyFlagBits::eHostCoherent ) result += "HostCoherent | ";
+    if ( value & MemoryPropertyFlagBits::eHostCached ) result += "HostCached | ";
+    if ( value & MemoryPropertyFlagBits::eLazilyAllocated ) result += "LazilyAllocated | ";
+    if ( value & MemoryPropertyFlagBits::eProtected ) result += "Protected";
+  }
+
+  enum class ObjectEntryUsageFlagBitsNVX
+  {
+    eGraphics = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX,
+    eCompute = VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ObjectEntryUsageFlagBitsNVX value )
+  {
+    switch ( value )
+    {
+      case ObjectEntryUsageFlagBitsNVX::eGraphics : return "Graphics";
+      case ObjectEntryUsageFlagBitsNVX::eCompute : return "Compute";
+      default: return "invalid";
+    }
+  }
+
+  using ObjectEntryUsageFlagsNVX = Flags<ObjectEntryUsageFlagBitsNVX, VkObjectEntryUsageFlagsNVX>;
+
+  VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 )
+  {
+    return ObjectEntryUsageFlagsNVX( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits )
+  {
+    return ~( ObjectEntryUsageFlagsNVX( bits ) );
+  }
+
+  template <> struct FlagTraits<ObjectEntryUsageFlagBitsNVX>
+  {
+    enum
+    {
+      allFlags = VkFlags(ObjectEntryUsageFlagBitsNVX::eGraphics) | VkFlags(ObjectEntryUsageFlagBitsNVX::eCompute)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ObjectEntryUsageFlagsNVX value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ObjectEntryUsageFlagBitsNVX::eGraphics ) result += "Graphics | ";
+    if ( value & ObjectEntryUsageFlagBitsNVX::eCompute ) result += "Compute";
+  }
+
+  enum class PeerMemoryFeatureFlagBits
+  {
+    eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
+    eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
+    eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
+    eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT,
+    eCopySrcKHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR,
+    eCopyDstKHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR,
+    eGenericSrcKHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR,
+    eGenericDstKHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PeerMemoryFeatureFlagBits value )
+  {
+    switch ( value )
+    {
+      case PeerMemoryFeatureFlagBits::eCopySrc : return "CopySrc";
+      case PeerMemoryFeatureFlagBits::eCopyDst : return "CopyDst";
+      case PeerMemoryFeatureFlagBits::eGenericSrc : return "GenericSrc";
+      case PeerMemoryFeatureFlagBits::eGenericDst : return "GenericDst";
+      default: return "invalid";
+    }
+  }
+
+  using PeerMemoryFeatureFlags = Flags<PeerMemoryFeatureFlagBits, VkPeerMemoryFeatureFlags>;
+
+  VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator|( PeerMemoryFeatureFlagBits bit0, PeerMemoryFeatureFlagBits bit1 )
+  {
+    return PeerMemoryFeatureFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator~( PeerMemoryFeatureFlagBits bits )
+  {
+    return ~( PeerMemoryFeatureFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<PeerMemoryFeatureFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(PeerMemoryFeatureFlagBits::eCopySrc) | VkFlags(PeerMemoryFeatureFlagBits::eCopyDst) | VkFlags(PeerMemoryFeatureFlagBits::eGenericSrc) | VkFlags(PeerMemoryFeatureFlagBits::eGenericDst)
+    };
+  };
+
+  using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags;
+
+  VULKAN_HPP_INLINE std::string to_string( PeerMemoryFeatureFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & PeerMemoryFeatureFlagBits::eCopySrc ) result += "CopySrc | ";
+    if ( value & PeerMemoryFeatureFlagBits::eCopyDst ) result += "CopyDst | ";
+    if ( value & PeerMemoryFeatureFlagBits::eGenericSrc ) result += "GenericSrc | ";
+    if ( value & PeerMemoryFeatureFlagBits::eGenericDst ) result += "GenericDst";
+  }
+
+  enum class PipelineCacheCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits, VkPipelineCacheCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineColorBlendStateCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits, VkPipelineColorBlendStateCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineCoverageModulationStateCreateFlagBitsNV
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCoverageModulationStateCreateFlagBitsNV )
+  {
+    return "(void)";
+  }
+
+  using PipelineCoverageModulationStateCreateFlagsNV = Flags<PipelineCoverageModulationStateCreateFlagBitsNV, VkPipelineCoverageModulationStateCreateFlagsNV>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCoverageModulationStateCreateFlagsNV  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineCoverageToColorStateCreateFlagBitsNV
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCoverageToColorStateCreateFlagBitsNV )
+  {
+    return "(void)";
+  }
+
+  using PipelineCoverageToColorStateCreateFlagsNV = Flags<PipelineCoverageToColorStateCreateFlagBitsNV, VkPipelineCoverageToColorStateCreateFlagsNV>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCoverageToColorStateCreateFlagsNV  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineCreateFlagBits
+  {
+    eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT,
+    eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,
+    eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT,
+    eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
+    eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE,
+    eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV,
+    eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR,
+    eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlagBits value )
+  {
+    switch ( value )
+    {
+      case PipelineCreateFlagBits::eDisableOptimization : return "DisableOptimization";
+      case PipelineCreateFlagBits::eAllowDerivatives : return "AllowDerivatives";
+      case PipelineCreateFlagBits::eDerivative : return "Derivative";
+      case PipelineCreateFlagBits::eViewIndexFromDeviceIndex : return "ViewIndexFromDeviceIndex";
+      case PipelineCreateFlagBits::eDispatchBase : return "DispatchBase";
+      case PipelineCreateFlagBits::eDeferCompileNV : return "DeferCompileNV";
+      default: return "invalid";
+    }
+  }
+
+  using PipelineCreateFlags = Flags<PipelineCreateFlagBits, VkPipelineCreateFlags>;
+
+  VULKAN_HPP_INLINE PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
+  {
+    return PipelineCreateFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE PipelineCreateFlags operator~( PipelineCreateFlagBits bits )
+  {
+    return ~( PipelineCreateFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<PipelineCreateFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) | VkFlags(PipelineCreateFlagBits::eDeferCompileNV)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & PipelineCreateFlagBits::eDisableOptimization ) result += "DisableOptimization | ";
+    if ( value & PipelineCreateFlagBits::eAllowDerivatives ) result += "AllowDerivatives | ";
+    if ( value & PipelineCreateFlagBits::eDerivative ) result += "Derivative | ";
+    if ( value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex ) result += "ViewIndexFromDeviceIndex | ";
+    if ( value & PipelineCreateFlagBits::eDispatchBase ) result += "DispatchBase | ";
+    if ( value & PipelineCreateFlagBits::eDeferCompileNV ) result += "DeferCompileNV";
+  }
+
+  enum class PipelineDepthStencilStateCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits, VkPipelineDepthStencilStateCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineDiscardRectangleStateCreateFlagBitsEXT
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
+  using PipelineDiscardRectangleStateCreateFlagsEXT = Flags<PipelineDiscardRectangleStateCreateFlagBitsEXT, VkPipelineDiscardRectangleStateCreateFlagsEXT>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagsEXT  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineDynamicStateCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using PipelineDynamicStateCreateFlags = Flags<PipelineDynamicStateCreateFlagBits, VkPipelineDynamicStateCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineInputAssemblyStateCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using PipelineInputAssemblyStateCreateFlags = Flags<PipelineInputAssemblyStateCreateFlagBits, VkPipelineInputAssemblyStateCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineLayoutCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits, VkPipelineLayoutCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineMultisampleStateCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using PipelineMultisampleStateCreateFlags = Flags<PipelineMultisampleStateCreateFlagBits, VkPipelineMultisampleStateCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationConservativeStateCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
+  using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags<PipelineRasterizationConservativeStateCreateFlagBitsEXT, VkPipelineRasterizationConservativeStateCreateFlagsEXT>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationConservativeStateCreateFlagsEXT  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineRasterizationStateCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using PipelineRasterizationStateCreateFlags = Flags<PipelineRasterizationStateCreateFlagBits, VkPipelineRasterizationStateCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineRasterizationStateStreamCreateFlagBitsEXT
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
+  using PipelineRasterizationStateStreamCreateFlagsEXT = Flags<PipelineRasterizationStateStreamCreateFlagBitsEXT, VkPipelineRasterizationStateStreamCreateFlagsEXT>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagsEXT  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineShaderStageCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits, VkPipelineShaderStageCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineStageFlagBits
+  {
+    eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+    eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
+    eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
+    eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
+    eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT,
+    eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT,
+    eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
+    eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+    eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
+    eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+    eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+    eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+    eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT,
+    eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+    eHost = VK_PIPELINE_STAGE_HOST_BIT,
+    eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
+    eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+    eTransformFeedbackEXT = VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT,
+    eConditionalRenderingEXT = VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT,
+    eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX,
+    eShadingRateImageNV = VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV,
+    eRayTracingShaderNV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV,
+    eAccelerationStructureBuildNV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV,
+    eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV,
+    eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV,
+    eFragmentDensityProcessEXT = VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineStageFlagBits value )
+  {
+    switch ( value )
+    {
+      case PipelineStageFlagBits::eTopOfPipe : return "TopOfPipe";
+      case PipelineStageFlagBits::eDrawIndirect : return "DrawIndirect";
+      case PipelineStageFlagBits::eVertexInput : return "VertexInput";
+      case PipelineStageFlagBits::eVertexShader : return "VertexShader";
+      case PipelineStageFlagBits::eTessellationControlShader : return "TessellationControlShader";
+      case PipelineStageFlagBits::eTessellationEvaluationShader : return "TessellationEvaluationShader";
+      case PipelineStageFlagBits::eGeometryShader : return "GeometryShader";
+      case PipelineStageFlagBits::eFragmentShader : return "FragmentShader";
+      case PipelineStageFlagBits::eEarlyFragmentTests : return "EarlyFragmentTests";
+      case PipelineStageFlagBits::eLateFragmentTests : return "LateFragmentTests";
+      case PipelineStageFlagBits::eColorAttachmentOutput : return "ColorAttachmentOutput";
+      case PipelineStageFlagBits::eComputeShader : return "ComputeShader";
+      case PipelineStageFlagBits::eTransfer : return "Transfer";
+      case PipelineStageFlagBits::eBottomOfPipe : return "BottomOfPipe";
+      case PipelineStageFlagBits::eHost : return "Host";
+      case PipelineStageFlagBits::eAllGraphics : return "AllGraphics";
+      case PipelineStageFlagBits::eAllCommands : return "AllCommands";
+      case PipelineStageFlagBits::eTransformFeedbackEXT : return "TransformFeedbackEXT";
+      case PipelineStageFlagBits::eConditionalRenderingEXT : return "ConditionalRenderingEXT";
+      case PipelineStageFlagBits::eCommandProcessNVX : return "CommandProcessNVX";
+      case PipelineStageFlagBits::eShadingRateImageNV : return "ShadingRateImageNV";
+      case PipelineStageFlagBits::eRayTracingShaderNV : return "RayTracingShaderNV";
+      case PipelineStageFlagBits::eAccelerationStructureBuildNV : return "AccelerationStructureBuildNV";
+      case PipelineStageFlagBits::eTaskShaderNV : return "TaskShaderNV";
+      case PipelineStageFlagBits::eMeshShaderNV : return "MeshShaderNV";
+      case PipelineStageFlagBits::eFragmentDensityProcessEXT : return "FragmentDensityProcessEXT";
+      default: return "invalid";
+    }
+  }
+
+  using PipelineStageFlags = Flags<PipelineStageFlagBits, VkPipelineStageFlags>;
+
+  VULKAN_HPP_INLINE PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
+  {
+    return PipelineStageFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE PipelineStageFlags operator~( PipelineStageFlagBits bits )
+  {
+    return ~( PipelineStageFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<PipelineStageFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eTransformFeedbackEXT) | VkFlags(PipelineStageFlagBits::eConditionalRenderingEXT) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) | VkFlags(PipelineStageFlagBits::eShadingRateImageNV) | VkFlags(PipelineStageFlagBits::eRayTracingShaderNV) | VkFlags(PipelineStageFlagBits::eAccelerationStructureBuildNV) | VkFlags(PipelineStageFlagBits::eTaskShaderNV) | VkFlags(PipelineStageFlagBits::eMeshShaderNV) | VkFlags(PipelineStageFlagBits::eFragmentDensityProcessEXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & PipelineStageFlagBits::eTopOfPipe ) result += "TopOfPipe | ";
+    if ( value & PipelineStageFlagBits::eDrawIndirect ) result += "DrawIndirect | ";
+    if ( value & PipelineStageFlagBits::eVertexInput ) result += "VertexInput | ";
+    if ( value & PipelineStageFlagBits::eVertexShader ) result += "VertexShader | ";
+    if ( value & PipelineStageFlagBits::eTessellationControlShader ) result += "TessellationControlShader | ";
+    if ( value & PipelineStageFlagBits::eTessellationEvaluationShader ) result += "TessellationEvaluationShader | ";
+    if ( value & PipelineStageFlagBits::eGeometryShader ) result += "GeometryShader | ";
+    if ( value & PipelineStageFlagBits::eFragmentShader ) result += "FragmentShader | ";
+    if ( value & PipelineStageFlagBits::eEarlyFragmentTests ) result += "EarlyFragmentTests | ";
+    if ( value & PipelineStageFlagBits::eLateFragmentTests ) result += "LateFragmentTests | ";
+    if ( value & PipelineStageFlagBits::eColorAttachmentOutput ) result += "ColorAttachmentOutput | ";
+    if ( value & PipelineStageFlagBits::eComputeShader ) result += "ComputeShader | ";
+    if ( value & PipelineStageFlagBits::eTransfer ) result += "Transfer | ";
+    if ( value & PipelineStageFlagBits::eBottomOfPipe ) result += "BottomOfPipe | ";
+    if ( value & PipelineStageFlagBits::eHost ) result += "Host | ";
+    if ( value & PipelineStageFlagBits::eAllGraphics ) result += "AllGraphics | ";
+    if ( value & PipelineStageFlagBits::eAllCommands ) result += "AllCommands | ";
+    if ( value & PipelineStageFlagBits::eTransformFeedbackEXT ) result += "TransformFeedbackEXT | ";
+    if ( value & PipelineStageFlagBits::eConditionalRenderingEXT ) result += "ConditionalRenderingEXT | ";
+    if ( value & PipelineStageFlagBits::eCommandProcessNVX ) result += "CommandProcessNVX | ";
+    if ( value & PipelineStageFlagBits::eShadingRateImageNV ) result += "ShadingRateImageNV | ";
+    if ( value & PipelineStageFlagBits::eRayTracingShaderNV ) result += "RayTracingShaderNV | ";
+    if ( value & PipelineStageFlagBits::eAccelerationStructureBuildNV ) result += "AccelerationStructureBuildNV | ";
+    if ( value & PipelineStageFlagBits::eTaskShaderNV ) result += "TaskShaderNV | ";
+    if ( value & PipelineStageFlagBits::eMeshShaderNV ) result += "MeshShaderNV | ";
+    if ( value & PipelineStageFlagBits::eFragmentDensityProcessEXT ) result += "FragmentDensityProcessEXT";
+  }
+
+  enum class PipelineTessellationStateCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using PipelineTessellationStateCreateFlags = Flags<PipelineTessellationStateCreateFlagBits, VkPipelineTessellationStateCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineVertexInputStateCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using PipelineVertexInputStateCreateFlags = Flags<PipelineVertexInputStateCreateFlagBits, VkPipelineVertexInputStateCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineViewportStateCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using PipelineViewportStateCreateFlags = Flags<PipelineViewportStateCreateFlagBits, VkPipelineViewportStateCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class PipelineViewportSwizzleStateCreateFlagBitsNV
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineViewportSwizzleStateCreateFlagBitsNV )
+  {
+    return "(void)";
+  }
+
+  using PipelineViewportSwizzleStateCreateFlagsNV = Flags<PipelineViewportSwizzleStateCreateFlagBitsNV, VkPipelineViewportSwizzleStateCreateFlagsNV>;
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineViewportSwizzleStateCreateFlagsNV  )
+  {
+    return "{}";
+  }
+
+  enum class QueryControlFlagBits
+  {
+    ePrecise = VK_QUERY_CONTROL_PRECISE_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( QueryControlFlagBits value )
+  {
+    switch ( value )
+    {
+      case QueryControlFlagBits::ePrecise : return "Precise";
+      default: return "invalid";
+    }
+  }
+
+  using QueryControlFlags = Flags<QueryControlFlagBits, VkQueryControlFlags>;
+
+  VULKAN_HPP_INLINE QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
+  {
+    return QueryControlFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE QueryControlFlags operator~( QueryControlFlagBits bits )
+  {
+    return ~( QueryControlFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<QueryControlFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(QueryControlFlagBits::ePrecise)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( QueryControlFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & QueryControlFlagBits::ePrecise ) result += "Precise";
+  }
+
+  enum class QueryPipelineStatisticFlagBits
+  {
+    eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT,
+    eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT,
+    eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT,
+    eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT,
+    eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT,
+    eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT,
+    eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT,
+    eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT,
+    eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT,
+    eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT,
+    eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( QueryPipelineStatisticFlagBits value )
+  {
+    switch ( value )
+    {
+      case QueryPipelineStatisticFlagBits::eInputAssemblyVertices : return "InputAssemblyVertices";
+      case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives : return "InputAssemblyPrimitives";
+      case QueryPipelineStatisticFlagBits::eVertexShaderInvocations : return "VertexShaderInvocations";
+      case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations : return "GeometryShaderInvocations";
+      case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives : return "GeometryShaderPrimitives";
+      case QueryPipelineStatisticFlagBits::eClippingInvocations : return "ClippingInvocations";
+      case QueryPipelineStatisticFlagBits::eClippingPrimitives : return "ClippingPrimitives";
+      case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations : return "FragmentShaderInvocations";
+      case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches : return "TessellationControlShaderPatches";
+      case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations : return "TessellationEvaluationShaderInvocations";
+      case QueryPipelineStatisticFlagBits::eComputeShaderInvocations : return "ComputeShaderInvocations";
+      default: return "invalid";
+    }
+  }
+
+  using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits, VkQueryPipelineStatisticFlags>;
+
+  VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
+  {
+    return QueryPipelineStatisticFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits )
+  {
+    return ~( QueryPipelineStatisticFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<QueryPipelineStatisticFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) | VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( QueryPipelineStatisticFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices ) result += "InputAssemblyVertices | ";
+    if ( value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives ) result += "InputAssemblyPrimitives | ";
+    if ( value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations ) result += "VertexShaderInvocations | ";
+    if ( value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations ) result += "GeometryShaderInvocations | ";
+    if ( value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives ) result += "GeometryShaderPrimitives | ";
+    if ( value & QueryPipelineStatisticFlagBits::eClippingInvocations ) result += "ClippingInvocations | ";
+    if ( value & QueryPipelineStatisticFlagBits::eClippingPrimitives ) result += "ClippingPrimitives | ";
+    if ( value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations ) result += "FragmentShaderInvocations | ";
+    if ( value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches ) result += "TessellationControlShaderPatches | ";
+    if ( value & QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations ) result += "TessellationEvaluationShaderInvocations | ";
+    if ( value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations ) result += "ComputeShaderInvocations";
+  }
+
+  enum class QueryPoolCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using QueryPoolCreateFlags = Flags<QueryPoolCreateFlagBits, VkQueryPoolCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class QueryResultFlagBits
+  {
+    e64 = VK_QUERY_RESULT_64_BIT,
+    eWait = VK_QUERY_RESULT_WAIT_BIT,
+    eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT,
+    ePartial = VK_QUERY_RESULT_PARTIAL_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( QueryResultFlagBits value )
+  {
+    switch ( value )
+    {
+      case QueryResultFlagBits::e64 : return "64";
+      case QueryResultFlagBits::eWait : return "Wait";
+      case QueryResultFlagBits::eWithAvailability : return "WithAvailability";
+      case QueryResultFlagBits::ePartial : return "Partial";
+      default: return "invalid";
+    }
+  }
+
+  using QueryResultFlags = Flags<QueryResultFlagBits, VkQueryResultFlags>;
+
+  VULKAN_HPP_INLINE QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
+  {
+    return QueryResultFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE QueryResultFlags operator~( QueryResultFlagBits bits )
+  {
+    return ~( QueryResultFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<QueryResultFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(QueryResultFlagBits::e64) | VkFlags(QueryResultFlagBits::eWait) | VkFlags(QueryResultFlagBits::eWithAvailability) | VkFlags(QueryResultFlagBits::ePartial)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( QueryResultFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & QueryResultFlagBits::e64 ) result += "64 | ";
+    if ( value & QueryResultFlagBits::eWait ) result += "Wait | ";
+    if ( value & QueryResultFlagBits::eWithAvailability ) result += "WithAvailability | ";
+    if ( value & QueryResultFlagBits::ePartial ) result += "Partial";
+  }
+
+  enum class QueueFlagBits
+  {
+    eGraphics = VK_QUEUE_GRAPHICS_BIT,
+    eCompute = VK_QUEUE_COMPUTE_BIT,
+    eTransfer = VK_QUEUE_TRANSFER_BIT,
+    eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT,
+    eProtected = VK_QUEUE_PROTECTED_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( QueueFlagBits value )
+  {
+    switch ( value )
+    {
+      case QueueFlagBits::eGraphics : return "Graphics";
+      case QueueFlagBits::eCompute : return "Compute";
+      case QueueFlagBits::eTransfer : return "Transfer";
+      case QueueFlagBits::eSparseBinding : return "SparseBinding";
+      case QueueFlagBits::eProtected : return "Protected";
+      default: return "invalid";
+    }
+  }
+
+  using QueueFlags = Flags<QueueFlagBits, VkQueueFlags>;
+
+  VULKAN_HPP_INLINE QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 )
+  {
+    return QueueFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE QueueFlags operator~( QueueFlagBits bits )
+  {
+    return ~( QueueFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<QueueFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(QueueFlagBits::eGraphics) | VkFlags(QueueFlagBits::eCompute) | VkFlags(QueueFlagBits::eTransfer) | VkFlags(QueueFlagBits::eSparseBinding) | VkFlags(QueueFlagBits::eProtected)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( QueueFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & QueueFlagBits::eGraphics ) result += "Graphics | ";
+    if ( value & QueueFlagBits::eCompute ) result += "Compute | ";
+    if ( value & QueueFlagBits::eTransfer ) result += "Transfer | ";
+    if ( value & QueueFlagBits::eSparseBinding ) result += "SparseBinding | ";
+    if ( value & QueueFlagBits::eProtected ) result += "Protected";
+  }
+
+  enum class RenderPassCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( RenderPassCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using RenderPassCreateFlags = Flags<RenderPassCreateFlagBits, VkRenderPassCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( RenderPassCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class SampleCountFlagBits
+  {
+    e1 = VK_SAMPLE_COUNT_1_BIT,
+    e2 = VK_SAMPLE_COUNT_2_BIT,
+    e4 = VK_SAMPLE_COUNT_4_BIT,
+    e8 = VK_SAMPLE_COUNT_8_BIT,
+    e16 = VK_SAMPLE_COUNT_16_BIT,
+    e32 = VK_SAMPLE_COUNT_32_BIT,
+    e64 = VK_SAMPLE_COUNT_64_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SampleCountFlagBits value )
+  {
+    switch ( value )
+    {
+      case SampleCountFlagBits::e1 : return "1";
+      case SampleCountFlagBits::e2 : return "2";
+      case SampleCountFlagBits::e4 : return "4";
+      case SampleCountFlagBits::e8 : return "8";
+      case SampleCountFlagBits::e16 : return "16";
+      case SampleCountFlagBits::e32 : return "32";
+      case SampleCountFlagBits::e64 : return "64";
+      default: return "invalid";
+    }
+  }
+
+  using SampleCountFlags = Flags<SampleCountFlagBits, VkSampleCountFlags>;
+
+  VULKAN_HPP_INLINE SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
+  {
+    return SampleCountFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE SampleCountFlags operator~( SampleCountFlagBits bits )
+  {
+    return ~( SampleCountFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<SampleCountFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) | VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) | VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) | VkFlags(SampleCountFlagBits::e64)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SampleCountFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & SampleCountFlagBits::e1 ) result += "1 | ";
+    if ( value & SampleCountFlagBits::e2 ) result += "2 | ";
+    if ( value & SampleCountFlagBits::e4 ) result += "4 | ";
+    if ( value & SampleCountFlagBits::e8 ) result += "8 | ";
+    if ( value & SampleCountFlagBits::e16 ) result += "16 | ";
+    if ( value & SampleCountFlagBits::e32 ) result += "32 | ";
+    if ( value & SampleCountFlagBits::e64 ) result += "64";
+  }
+
+  enum class SamplerCreateFlagBits
+  {
+    eSubsampledEXT = VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT,
+    eSubsampledCoarseReconstructionEXT = VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SamplerCreateFlagBits value )
+  {
+    switch ( value )
+    {
+      case SamplerCreateFlagBits::eSubsampledEXT : return "SubsampledEXT";
+      case SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT : return "SubsampledCoarseReconstructionEXT";
+      default: return "invalid";
+    }
+  }
+
+  using SamplerCreateFlags = Flags<SamplerCreateFlagBits, VkSamplerCreateFlags>;
+
+  VULKAN_HPP_INLINE SamplerCreateFlags operator|( SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1 )
+  {
+    return SamplerCreateFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE SamplerCreateFlags operator~( SamplerCreateFlagBits bits )
+  {
+    return ~( SamplerCreateFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<SamplerCreateFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(SamplerCreateFlagBits::eSubsampledEXT) | VkFlags(SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SamplerCreateFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & SamplerCreateFlagBits::eSubsampledEXT ) result += "SubsampledEXT | ";
+    if ( value & SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT ) result += "SubsampledCoarseReconstructionEXT";
+  }
+
+  enum class SemaphoreCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits, VkSemaphoreCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class SemaphoreImportFlagBits
+  {
+    eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
+    eTemporaryKHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SemaphoreImportFlagBits value )
+  {
+    switch ( value )
+    {
+      case SemaphoreImportFlagBits::eTemporary : return "Temporary";
+      default: return "invalid";
+    }
+  }
+
+  using SemaphoreImportFlags = Flags<SemaphoreImportFlagBits, VkSemaphoreImportFlags>;
+
+  VULKAN_HPP_INLINE SemaphoreImportFlags operator|( SemaphoreImportFlagBits bit0, SemaphoreImportFlagBits bit1 )
+  {
+    return SemaphoreImportFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE SemaphoreImportFlags operator~( SemaphoreImportFlagBits bits )
+  {
+    return ~( SemaphoreImportFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<SemaphoreImportFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(SemaphoreImportFlagBits::eTemporary)
+    };
+  };
+
+  using SemaphoreImportFlagsKHR = SemaphoreImportFlags;
+
+  VULKAN_HPP_INLINE std::string to_string( SemaphoreImportFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & SemaphoreImportFlagBits::eTemporary ) result += "Temporary";
+  }
+
+  enum class ShaderModuleCreateFlagBits
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( ShaderModuleCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  using ShaderModuleCreateFlags = Flags<ShaderModuleCreateFlagBits, VkShaderModuleCreateFlags>;
+
+  VULKAN_HPP_INLINE std::string to_string( ShaderModuleCreateFlags  )
+  {
+    return "{}";
+  }
+
+  enum class ShaderStageFlagBits
+  {
+    eVertex = VK_SHADER_STAGE_VERTEX_BIT,
+    eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
+    eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
+    eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT,
+    eFragment = VK_SHADER_STAGE_FRAGMENT_BIT,
+    eCompute = VK_SHADER_STAGE_COMPUTE_BIT,
+    eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS,
+    eAll = VK_SHADER_STAGE_ALL,
+    eRaygenNV = VK_SHADER_STAGE_RAYGEN_BIT_NV,
+    eAnyHitNV = VK_SHADER_STAGE_ANY_HIT_BIT_NV,
+    eClosestHitNV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV,
+    eMissNV = VK_SHADER_STAGE_MISS_BIT_NV,
+    eIntersectionNV = VK_SHADER_STAGE_INTERSECTION_BIT_NV,
+    eCallableNV = VK_SHADER_STAGE_CALLABLE_BIT_NV,
+    eTaskNV = VK_SHADER_STAGE_TASK_BIT_NV,
+    eMeshNV = VK_SHADER_STAGE_MESH_BIT_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ShaderStageFlagBits value )
+  {
+    switch ( value )
+    {
+      case ShaderStageFlagBits::eVertex : return "Vertex";
+      case ShaderStageFlagBits::eTessellationControl : return "TessellationControl";
+      case ShaderStageFlagBits::eTessellationEvaluation : return "TessellationEvaluation";
+      case ShaderStageFlagBits::eGeometry : return "Geometry";
+      case ShaderStageFlagBits::eFragment : return "Fragment";
+      case ShaderStageFlagBits::eCompute : return "Compute";
+      case ShaderStageFlagBits::eAllGraphics : return "AllGraphics";
+      case ShaderStageFlagBits::eAll : return "All";
+      case ShaderStageFlagBits::eRaygenNV : return "RaygenNV";
+      case ShaderStageFlagBits::eAnyHitNV : return "AnyHitNV";
+      case ShaderStageFlagBits::eClosestHitNV : return "ClosestHitNV";
+      case ShaderStageFlagBits::eMissNV : return "MissNV";
+      case ShaderStageFlagBits::eIntersectionNV : return "IntersectionNV";
+      case ShaderStageFlagBits::eCallableNV : return "CallableNV";
+      case ShaderStageFlagBits::eTaskNV : return "TaskNV";
+      case ShaderStageFlagBits::eMeshNV : return "MeshNV";
+      default: return "invalid";
+    }
+  }
+
+  using ShaderStageFlags = Flags<ShaderStageFlagBits, VkShaderStageFlags>;
+
+  VULKAN_HPP_INLINE ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
+  {
+    return ShaderStageFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE ShaderStageFlags operator~( ShaderStageFlagBits bits )
+  {
+    return ~( ShaderStageFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<ShaderStageFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll) | VkFlags(ShaderStageFlagBits::eRaygenNV) | VkFlags(ShaderStageFlagBits::eAnyHitNV) | VkFlags(ShaderStageFlagBits::eClosestHitNV) | VkFlags(ShaderStageFlagBits::eMissNV) | VkFlags(ShaderStageFlagBits::eIntersectionNV) | VkFlags(ShaderStageFlagBits::eCallableNV) | VkFlags(ShaderStageFlagBits::eTaskNV) | VkFlags(ShaderStageFlagBits::eMeshNV)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ShaderStageFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & ShaderStageFlagBits::eVertex ) result += "Vertex | ";
+    if ( value & ShaderStageFlagBits::eTessellationControl ) result += "TessellationControl | ";
+    if ( value & ShaderStageFlagBits::eTessellationEvaluation ) result += "TessellationEvaluation | ";
+    if ( value & ShaderStageFlagBits::eGeometry ) result += "Geometry | ";
+    if ( value & ShaderStageFlagBits::eFragment ) result += "Fragment | ";
+    if ( value & ShaderStageFlagBits::eCompute ) result += "Compute | ";
+    if ( value & ShaderStageFlagBits::eAllGraphics ) result += "AllGraphics | ";
+    if ( value & ShaderStageFlagBits::eAll ) result += "All | ";
+    if ( value & ShaderStageFlagBits::eRaygenNV ) result += "RaygenNV | ";
+    if ( value & ShaderStageFlagBits::eAnyHitNV ) result += "AnyHitNV | ";
+    if ( value & ShaderStageFlagBits::eClosestHitNV ) result += "ClosestHitNV | ";
+    if ( value & ShaderStageFlagBits::eMissNV ) result += "MissNV | ";
+    if ( value & ShaderStageFlagBits::eIntersectionNV ) result += "IntersectionNV | ";
+    if ( value & ShaderStageFlagBits::eCallableNV ) result += "CallableNV | ";
+    if ( value & ShaderStageFlagBits::eTaskNV ) result += "TaskNV | ";
+    if ( value & ShaderStageFlagBits::eMeshNV ) result += "MeshNV";
+  }
+
+  enum class SparseImageFormatFlagBits
+  {
+    eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT,
+    eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT,
+    eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SparseImageFormatFlagBits value )
+  {
+    switch ( value )
+    {
+      case SparseImageFormatFlagBits::eSingleMiptail : return "SingleMiptail";
+      case SparseImageFormatFlagBits::eAlignedMipSize : return "AlignedMipSize";
+      case SparseImageFormatFlagBits::eNonstandardBlockSize : return "NonstandardBlockSize";
+      default: return "invalid";
+    }
+  }
+
+  using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits, VkSparseImageFormatFlags>;
+
+  VULKAN_HPP_INLINE SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
+  {
+    return SparseImageFormatFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits )
+  {
+    return ~( SparseImageFormatFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<SparseImageFormatFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) | VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) | VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SparseImageFormatFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & SparseImageFormatFlagBits::eSingleMiptail ) result += "SingleMiptail | ";
+    if ( value & SparseImageFormatFlagBits::eAlignedMipSize ) result += "AlignedMipSize | ";
+    if ( value & SparseImageFormatFlagBits::eNonstandardBlockSize ) result += "NonstandardBlockSize";
+  }
+
+  enum class SparseMemoryBindFlagBits
+  {
+    eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SparseMemoryBindFlagBits value )
+  {
+    switch ( value )
+    {
+      case SparseMemoryBindFlagBits::eMetadata : return "Metadata";
+      default: return "invalid";
+    }
+  }
+
+  using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits, VkSparseMemoryBindFlags>;
+
+  VULKAN_HPP_INLINE SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
+  {
+    return SparseMemoryBindFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits )
+  {
+    return ~( SparseMemoryBindFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<SparseMemoryBindFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SparseMemoryBindFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & SparseMemoryBindFlagBits::eMetadata ) result += "Metadata";
+  }
+
+  enum class StencilFaceFlagBits
+  {
+    eFront = VK_STENCIL_FACE_FRONT_BIT,
+    eBack = VK_STENCIL_FACE_BACK_BIT,
+    eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( StencilFaceFlagBits value )
+  {
+    switch ( value )
+    {
+      case StencilFaceFlagBits::eFront : return "Front";
+      case StencilFaceFlagBits::eBack : return "Back";
+      case StencilFaceFlagBits::eVkStencilFrontAndBack : return "VkStencilFrontAndBack";
+      default: return "invalid";
+    }
+  }
+
+  using StencilFaceFlags = Flags<StencilFaceFlagBits, VkStencilFaceFlags>;
+
+  VULKAN_HPP_INLINE StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
+  {
+    return StencilFaceFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE StencilFaceFlags operator~( StencilFaceFlagBits bits )
+  {
+    return ~( StencilFaceFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<StencilFaceFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( StencilFaceFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & StencilFaceFlagBits::eFront ) result += "Front | ";
+    if ( value & StencilFaceFlagBits::eBack ) result += "Back | ";
+    if ( value & StencilFaceFlagBits::eVkStencilFrontAndBack ) result += "VkStencilFrontAndBack";
+  }
+
+  enum class SubgroupFeatureFlagBits
+  {
+    eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT,
+    eVote = VK_SUBGROUP_FEATURE_VOTE_BIT,
+    eArithmetic = VK_SUBGROUP_FEATURE_ARITHMETIC_BIT,
+    eBallot = VK_SUBGROUP_FEATURE_BALLOT_BIT,
+    eShuffle = VK_SUBGROUP_FEATURE_SHUFFLE_BIT,
+    eShuffleRelative = VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT,
+    eClustered = VK_SUBGROUP_FEATURE_CLUSTERED_BIT,
+    eQuad = VK_SUBGROUP_FEATURE_QUAD_BIT,
+    ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SubgroupFeatureFlagBits value )
+  {
+    switch ( value )
+    {
+      case SubgroupFeatureFlagBits::eBasic : return "Basic";
+      case SubgroupFeatureFlagBits::eVote : return "Vote";
+      case SubgroupFeatureFlagBits::eArithmetic : return "Arithmetic";
+      case SubgroupFeatureFlagBits::eBallot : return "Ballot";
+      case SubgroupFeatureFlagBits::eShuffle : return "Shuffle";
+      case SubgroupFeatureFlagBits::eShuffleRelative : return "ShuffleRelative";
+      case SubgroupFeatureFlagBits::eClustered : return "Clustered";
+      case SubgroupFeatureFlagBits::eQuad : return "Quad";
+      case SubgroupFeatureFlagBits::ePartitionedNV : return "PartitionedNV";
+      default: return "invalid";
+    }
+  }
+
+  using SubgroupFeatureFlags = Flags<SubgroupFeatureFlagBits, VkSubgroupFeatureFlags>;
+
+  VULKAN_HPP_INLINE SubgroupFeatureFlags operator|( SubgroupFeatureFlagBits bit0, SubgroupFeatureFlagBits bit1 )
+  {
+    return SubgroupFeatureFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE SubgroupFeatureFlags operator~( SubgroupFeatureFlagBits bits )
+  {
+    return ~( SubgroupFeatureFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<SubgroupFeatureFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(SubgroupFeatureFlagBits::eBasic) | VkFlags(SubgroupFeatureFlagBits::eVote) | VkFlags(SubgroupFeatureFlagBits::eArithmetic) | VkFlags(SubgroupFeatureFlagBits::eBallot) | VkFlags(SubgroupFeatureFlagBits::eShuffle) | VkFlags(SubgroupFeatureFlagBits::eShuffleRelative) | VkFlags(SubgroupFeatureFlagBits::eClustered) | VkFlags(SubgroupFeatureFlagBits::eQuad) | VkFlags(SubgroupFeatureFlagBits::ePartitionedNV)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SubgroupFeatureFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & SubgroupFeatureFlagBits::eBasic ) result += "Basic | ";
+    if ( value & SubgroupFeatureFlagBits::eVote ) result += "Vote | ";
+    if ( value & SubgroupFeatureFlagBits::eArithmetic ) result += "Arithmetic | ";
+    if ( value & SubgroupFeatureFlagBits::eBallot ) result += "Ballot | ";
+    if ( value & SubgroupFeatureFlagBits::eShuffle ) result += "Shuffle | ";
+    if ( value & SubgroupFeatureFlagBits::eShuffleRelative ) result += "ShuffleRelative | ";
+    if ( value & SubgroupFeatureFlagBits::eClustered ) result += "Clustered | ";
+    if ( value & SubgroupFeatureFlagBits::eQuad ) result += "Quad | ";
+    if ( value & SubgroupFeatureFlagBits::ePartitionedNV ) result += "PartitionedNV";
+  }
+
+  enum class SubpassDescriptionFlagBits
+  {
+    ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX,
+    ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlagBits value )
+  {
+    switch ( value )
+    {
+      case SubpassDescriptionFlagBits::ePerViewAttributesNVX : return "PerViewAttributesNVX";
+      case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX : return "PerViewPositionXOnlyNVX";
+      default: return "invalid";
+    }
+  }
+
+  using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits, VkSubpassDescriptionFlags>;
+
+  VULKAN_HPP_INLINE SubpassDescriptionFlags operator|( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
+  {
+    return SubpassDescriptionFlags( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE SubpassDescriptionFlags operator~( SubpassDescriptionFlagBits bits )
+  {
+    return ~( SubpassDescriptionFlags( bits ) );
+  }
+
+  template <> struct FlagTraits<SubpassDescriptionFlagBits>
+  {
+    enum
+    {
+      allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) | VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlags value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & SubpassDescriptionFlagBits::ePerViewAttributesNVX ) result += "PerViewAttributesNVX | ";
+    if ( value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX ) result += "PerViewPositionXOnlyNVX";
+  }
+
+  enum class SurfaceCounterFlagBitsEXT
+  {
+    eVblank = VK_SURFACE_COUNTER_VBLANK_EXT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SurfaceCounterFlagBitsEXT value )
+  {
+    switch ( value )
+    {
+      case SurfaceCounterFlagBitsEXT::eVblank : return "Vblank";
+      default: return "invalid";
+    }
+  }
+
+  using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT, VkSurfaceCounterFlagsEXT>;
+
+  VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator|( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 )
+  {
+    return SurfaceCounterFlagsEXT( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator~( SurfaceCounterFlagBitsEXT bits )
+  {
+    return ~( SurfaceCounterFlagsEXT( bits ) );
+  }
+
+  template <> struct FlagTraits<SurfaceCounterFlagBitsEXT>
+  {
+    enum
+    {
+      allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblank)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SurfaceCounterFlagsEXT value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & SurfaceCounterFlagBitsEXT::eVblank ) result += "Vblank";
+  }
+
+  enum class SurfaceTransformFlagBitsKHR
+  {
+    eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
+    eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR,
+    eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR,
+    eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR,
+    eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR,
+    eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR,
+    eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR,
+    eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR,
+    eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SurfaceTransformFlagBitsKHR value )
+  {
+    switch ( value )
+    {
+      case SurfaceTransformFlagBitsKHR::eIdentity : return "Identity";
+      case SurfaceTransformFlagBitsKHR::eRotate90 : return "Rotate90";
+      case SurfaceTransformFlagBitsKHR::eRotate180 : return "Rotate180";
+      case SurfaceTransformFlagBitsKHR::eRotate270 : return "Rotate270";
+      case SurfaceTransformFlagBitsKHR::eHorizontalMirror : return "HorizontalMirror";
+      case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 : return "HorizontalMirrorRotate90";
+      case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 : return "HorizontalMirrorRotate180";
+      case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 : return "HorizontalMirrorRotate270";
+      case SurfaceTransformFlagBitsKHR::eInherit : return "Inherit";
+      default: return "invalid";
+    }
+  }
+
+  using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR, VkSurfaceTransformFlagsKHR>;
+
+  VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
+  {
+    return SurfaceTransformFlagsKHR( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits )
+  {
+    return ~( SurfaceTransformFlagsKHR( bits ) );
+  }
+
+  template <> struct FlagTraits<SurfaceTransformFlagBitsKHR>
+  {
+    enum
+    {
+      allFlags = VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eInherit)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SurfaceTransformFlagsKHR value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & SurfaceTransformFlagBitsKHR::eIdentity ) result += "Identity | ";
+    if ( value & SurfaceTransformFlagBitsKHR::eRotate90 ) result += "Rotate90 | ";
+    if ( value & SurfaceTransformFlagBitsKHR::eRotate180 ) result += "Rotate180 | ";
+    if ( value & SurfaceTransformFlagBitsKHR::eRotate270 ) result += "Rotate270 | ";
+    if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirror ) result += "HorizontalMirror | ";
+    if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 ) result += "HorizontalMirrorRotate90 | ";
+    if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 ) result += "HorizontalMirrorRotate180 | ";
+    if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 ) result += "HorizontalMirrorRotate270 | ";
+    if ( value & SurfaceTransformFlagBitsKHR::eInherit ) result += "Inherit";
+  }
+
+  enum class SwapchainCreateFlagBitsKHR
+  {
+    eSplitInstanceBindRegions = VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR,
+    eProtected = VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR,
+    eMutableFormat = VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SwapchainCreateFlagBitsKHR value )
+  {
+    switch ( value )
+    {
+      case SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions : return "SplitInstanceBindRegions";
+      case SwapchainCreateFlagBitsKHR::eProtected : return "Protected";
+      case SwapchainCreateFlagBitsKHR::eMutableFormat : return "MutableFormat";
+      default: return "invalid";
+    }
+  }
+
+  using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR, VkSwapchainCreateFlagsKHR>;
+
+  VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator|( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
+  {
+    return SwapchainCreateFlagsKHR( bit0 ) | bit1;
+  }
+
+  VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator~( SwapchainCreateFlagBitsKHR bits )
+  {
+    return ~( SwapchainCreateFlagsKHR( bits ) );
+  }
+
+  template <> struct FlagTraits<SwapchainCreateFlagBitsKHR>
+  {
+    enum
+    {
+      allFlags = VkFlags(SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) | VkFlags(SwapchainCreateFlagBitsKHR::eProtected) | VkFlags(SwapchainCreateFlagBitsKHR::eMutableFormat)
+    };
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SwapchainCreateFlagsKHR value  )
+  {
+    if ( !value ) return "{}";
+    std::string result;
+
+    if ( value & SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions ) result += "SplitInstanceBindRegions | ";
+    if ( value & SwapchainCreateFlagBitsKHR::eProtected ) result += "Protected | ";
+    if ( value & SwapchainCreateFlagBitsKHR::eMutableFormat ) result += "MutableFormat";
+  }
+
+  enum class ValidationCacheCreateFlagBitsEXT
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( ValidationCacheCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
+  using ValidationCacheCreateFlagsEXT = Flags<ValidationCacheCreateFlagBitsEXT, VkValidationCacheCreateFlagsEXT>;
+
+  VULKAN_HPP_INLINE std::string to_string( ValidationCacheCreateFlagsEXT  )
+  {
+    return "{}";
+  }
+
+#ifdef VK_USE_PLATFORM_VI_NN
+  enum class ViSurfaceCreateFlagBitsNN
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( ViSurfaceCreateFlagBitsNN )
+  {
+    return "(void)";
+  }
+
+  using ViSurfaceCreateFlagsNN = Flags<ViSurfaceCreateFlagBitsNN, VkViSurfaceCreateFlagsNN>;
+
+  VULKAN_HPP_INLINE std::string to_string( ViSurfaceCreateFlagsNN  )
+  {
+    return "{}";
+  }
+#endif /*VK_USE_PLATFORM_VI_NN*/
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+  enum class WaylandSurfaceCreateFlagBitsKHR
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( WaylandSurfaceCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+
+  using WaylandSurfaceCreateFlagsKHR = Flags<WaylandSurfaceCreateFlagBitsKHR, VkWaylandSurfaceCreateFlagsKHR>;
+
+  VULKAN_HPP_INLINE std::string to_string( WaylandSurfaceCreateFlagsKHR  )
+  {
+    return "{}";
+  }
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  enum class Win32SurfaceCreateFlagBitsKHR
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( Win32SurfaceCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+
+  using Win32SurfaceCreateFlagsKHR = Flags<Win32SurfaceCreateFlagBitsKHR, VkWin32SurfaceCreateFlagsKHR>;
+
+  VULKAN_HPP_INLINE std::string to_string( Win32SurfaceCreateFlagsKHR  )
+  {
+    return "{}";
+  }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+  enum class XcbSurfaceCreateFlagBitsKHR
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( XcbSurfaceCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+
+  using XcbSurfaceCreateFlagsKHR = Flags<XcbSurfaceCreateFlagBitsKHR, VkXcbSurfaceCreateFlagsKHR>;
+
+  VULKAN_HPP_INLINE std::string to_string( XcbSurfaceCreateFlagsKHR  )
+  {
+    return "{}";
+  }
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+  enum class XlibSurfaceCreateFlagBitsKHR
+  {};
+
+  VULKAN_HPP_INLINE std::string to_string( XlibSurfaceCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+
+  using XlibSurfaceCreateFlagsKHR = Flags<XlibSurfaceCreateFlagBitsKHR, VkXlibSurfaceCreateFlagsKHR>;
+
+  VULKAN_HPP_INLINE std::string to_string( XlibSurfaceCreateFlagsKHR  )
+  {
+    return "{}";
+  }
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+} // namespace VULKAN_HPP_NAMESPACE
+
+namespace std
+{
+  template <>
+  struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
+  {};
+}
+
+namespace VULKAN_HPP_NAMESPACE
+{
+#ifndef VULKAN_HPP_NO_EXCEPTIONS
+#if defined(_MSC_VER) && (_MSC_VER == 1800)
+# define noexcept _NOEXCEPT
+#endif
+
+  class ErrorCategoryImpl : public std::error_category
+  {
+    public:
+    virtual const char* name() const noexcept override { return VULKAN_HPP_NAMESPACE_STRING"::Result"; }
+    virtual std::string message(int ev) const override { return to_string(static_cast<Result>(ev)); }
+  };
+
+  class Error
+  {
+    public:
+    virtual ~Error() = default;
+
+    virtual const char* what() const noexcept = 0;
+  };
+
+  class LogicError : public Error, public std::logic_error
+  {
+    public:
+    explicit LogicError( const std::string& what )
+      : Error(), std::logic_error(what) {}
+    explicit LogicError( char const * what )
+      : Error(), std::logic_error(what) {}
+    virtual ~LogicError() = default;
+
+    virtual const char* what() const noexcept { return std::logic_error::what(); }
+  };
+
+  class SystemError : public Error, public std::system_error
+  {
+    public:
+    SystemError( std::error_code ec )
+      : Error(), std::system_error(ec) {}
+    SystemError( std::error_code ec, std::string const& what )
+      : Error(), std::system_error(ec, what) {}
+    SystemError( std::error_code ec, char const * what )
+      : Error(), std::system_error(ec, what) {}
+    SystemError( int ev, std::error_category const& ecat )
+      : Error(), std::system_error(ev, ecat) {}
+    SystemError( int ev, std::error_category const& ecat, std::string const& what)
+      : Error(), std::system_error(ev, ecat, what) {}
+    SystemError( int ev, std::error_category const& ecat, char const * what)
+      : Error(), std::system_error(ev, ecat, what) {}
+    virtual ~SystemError() = default;
+
+    virtual const char* what() const noexcept { return std::system_error::what(); }
+  };
+
+#if defined(_MSC_VER) && (_MSC_VER == 1800)
+# undef noexcept
+#endif
+
+  VULKAN_HPP_INLINE const std::error_category& errorCategory()
+  {
+    static ErrorCategoryImpl instance;
+    return instance;
+  }
+
+  VULKAN_HPP_INLINE std::error_code make_error_code(Result e)
+  {
+    return std::error_code(static_cast<int>(e), errorCategory());
+  }
+
+  VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e)
+  {
+    return std::error_condition(static_cast<int>(e), errorCategory());
+  }
+
+  class OutOfHostMemoryError : public SystemError
+  {
+  public:
+    OutOfHostMemoryError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
+    OutOfHostMemoryError( char const * message )
+      : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
+  };
+
+  class OutOfDeviceMemoryError : public SystemError
+  {
+  public:
+    OutOfDeviceMemoryError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
+    OutOfDeviceMemoryError( char const * message )
+      : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
+  };
+
+  class InitializationFailedError : public SystemError
+  {
+  public:
+    InitializationFailedError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
+    InitializationFailedError( char const * message )
+      : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
+  };
+
+  class DeviceLostError : public SystemError
+  {
+  public:
+    DeviceLostError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
+    DeviceLostError( char const * message )
+      : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
+  };
+
+  class MemoryMapFailedError : public SystemError
+  {
+  public:
+    MemoryMapFailedError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
+    MemoryMapFailedError( char const * message )
+      : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
+  };
+
+  class LayerNotPresentError : public SystemError
+  {
+  public:
+    LayerNotPresentError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
+    LayerNotPresentError( char const * message )
+      : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
+  };
+
+  class ExtensionNotPresentError : public SystemError
+  {
+  public:
+    ExtensionNotPresentError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
+    ExtensionNotPresentError( char const * message )
+      : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
+  };
+
+  class FeatureNotPresentError : public SystemError
+  {
+  public:
+    FeatureNotPresentError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
+    FeatureNotPresentError( char const * message )
+      : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
+  };
+
+  class IncompatibleDriverError : public SystemError
+  {
+  public:
+    IncompatibleDriverError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
+    IncompatibleDriverError( char const * message )
+      : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
+  };
+
+  class TooManyObjectsError : public SystemError
+  {
+  public:
+    TooManyObjectsError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
+    TooManyObjectsError( char const * message )
+      : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
+  };
+
+  class FormatNotSupportedError : public SystemError
+  {
+  public:
+    FormatNotSupportedError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
+    FormatNotSupportedError( char const * message )
+      : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
+  };
+
+  class FragmentedPoolError : public SystemError
+  {
+  public:
+    FragmentedPoolError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
+    FragmentedPoolError( char const * message )
+      : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
+  };
+
+  class OutOfPoolMemoryError : public SystemError
+  {
+  public:
+    OutOfPoolMemoryError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
+    OutOfPoolMemoryError( char const * message )
+      : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
+  };
+
+  class InvalidExternalHandleError : public SystemError
+  {
+  public:
+    InvalidExternalHandleError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
+    InvalidExternalHandleError( char const * message )
+      : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
+  };
+
+  class SurfaceLostKHRError : public SystemError
+  {
+  public:
+    SurfaceLostKHRError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
+    SurfaceLostKHRError( char const * message )
+      : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
+  };
+
+  class NativeWindowInUseKHRError : public SystemError
+  {
+  public:
+    NativeWindowInUseKHRError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
+    NativeWindowInUseKHRError( char const * message )
+      : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
+  };
+
+  class OutOfDateKHRError : public SystemError
+  {
+  public:
+    OutOfDateKHRError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
+    OutOfDateKHRError( char const * message )
+      : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
+  };
+
+  class IncompatibleDisplayKHRError : public SystemError
+  {
+  public:
+    IncompatibleDisplayKHRError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
+    IncompatibleDisplayKHRError( char const * message )
+      : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
+  };
+
+  class ValidationFailedEXTError : public SystemError
+  {
+  public:
+    ValidationFailedEXTError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
+    ValidationFailedEXTError( char const * message )
+      : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
+  };
+
+  class InvalidShaderNVError : public SystemError
+  {
+  public:
+    InvalidShaderNVError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
+    InvalidShaderNVError( char const * message )
+      : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
+  };
+
+  class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError
+  {
+  public:
+    InvalidDrmFormatModifierPlaneLayoutEXTError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) {}
+    InvalidDrmFormatModifierPlaneLayoutEXTError( char const * message )
+      : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) {}
+  };
+
+  class FragmentationEXTError : public SystemError
+  {
+  public:
+    FragmentationEXTError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorFragmentationEXT ), message ) {}
+    FragmentationEXTError( char const * message )
+      : SystemError( make_error_code( Result::eErrorFragmentationEXT ), message ) {}
+  };
+
+  class NotPermittedEXTError : public SystemError
+  {
+  public:
+    NotPermittedEXTError( std::string const& message )
+      : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {}
+    NotPermittedEXTError( char const * message )
+      : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {}
+  };
+
+
+  VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
+  {
+    switch ( result )
+    {
+      case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError( message );
+      case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError( message );
+      case Result::eErrorInitializationFailed: throw InitializationFailedError( message );
+      case Result::eErrorDeviceLost: throw DeviceLostError( message );
+      case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError( message );
+      case Result::eErrorLayerNotPresent: throw LayerNotPresentError( message );
+      case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError( message );
+      case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError( message );
+      case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError( message );
+      case Result::eErrorTooManyObjects: throw TooManyObjectsError( message );
+      case Result::eErrorFormatNotSupported: throw FormatNotSupportedError( message );
+      case Result::eErrorFragmentedPool: throw FragmentedPoolError( message );
+      case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError( message );
+      case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError( message );
+      case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError( message );
+      case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError( message );
+      case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError( message );
+      case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError( message );
+      case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError( message );
+      case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError( message );
+      case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message );
+      case Result::eErrorFragmentationEXT: throw FragmentationEXTError( message );
+      case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError( message );
+      default: throw SystemError( make_error_code( result ) );
+    }
+  }
+#endif
+
+  template <typename T> void ignore(T const&) {}
+
+  template <typename T>
+  struct ResultValue
+  {
+    ResultValue( Result r, T & v )
+      : result( r )
+      , value( v )
+    {}
+
+    ResultValue( Result r, T && v )
+      : result( r )
+      , value( std::move( v ) )
+    {}
+
+    Result  result;
+    T       value;
+
+    operator std::tuple<Result&, T&>() { return std::tuple<Result&, T&>(result, value); }
+  };
+
+  template <typename T>
+  struct ResultValueType
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    typedef ResultValue<T>  type;
+#else
+    typedef T               type;
+#endif
+  };
+
+  template <>
+  struct ResultValueType<void>
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    typedef Result type;
+#else
+    typedef void   type;
+#endif
+  };
+
+  VULKAN_HPP_INLINE ResultValueType<void>::type createResultValue( Result result, char const * message )
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    ignore(message);
+    VULKAN_HPP_ASSERT( result == Result::eSuccess );
+    return result;
+#else
+    if ( result != Result::eSuccess )
+    {
+      throwResultException( result, message );
+    }
+#endif
+  }
+
+  template <typename T>
+  VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValue( Result result, T & data, char const * message )
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    ignore(message);
+    VULKAN_HPP_ASSERT( result == Result::eSuccess );
+    return ResultValue<T>( result, std::move( data ) );
+#else
+    if ( result != Result::eSuccess )
+    {
+      throwResultException( result, message );
+    }
+    return std::move( data );
+#endif
+  }
+
+  VULKAN_HPP_INLINE Result createResultValue( Result result, char const * message, std::initializer_list<Result> successCodes )
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    ignore(message);
+    VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
+#else
+    if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+    {
+      throwResultException( result, message );
+    }
+#endif
+    return result;
+  }
+
+  template <typename T>
+  VULKAN_HPP_INLINE ResultValue<T> createResultValue( Result result, T & data, char const * message, std::initializer_list<Result> successCodes )
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    ignore(message);
+    VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
+#else
+    if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+    {
+      throwResultException( result, message );
+    }
+#endif
+    return ResultValue<T>( result, data );
+  }
+
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename T, typename D>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<T,D>>::type createResultValue( Result result, T & data, char const * message, typename UniqueHandleTraits<T,D>::deleter const& deleter )
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    ignore(message);
+    VULKAN_HPP_ASSERT( result == Result::eSuccess );
+    return ResultValue<UniqueHandle<T,D>>( result, UniqueHandle<T,D>(data, deleter) );
+#else
+    if ( result != Result::eSuccess )
+    {
+      throwResultException( result, message );
+    }
+    return UniqueHandle<T,D>(data, deleter);
+#endif
+  }
+#endif
+
+  struct AccelerationStructureCreateInfoNV;
+  struct AccelerationStructureInfoNV;
+  struct AccelerationStructureMemoryRequirementsInfoNV;
+  struct AcquireNextImageInfoKHR;
+  struct AllocationCallbacks;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  struct AndroidHardwareBufferPropertiesANDROID;
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  struct AndroidSurfaceCreateInfoKHR;
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+  struct BindAccelerationStructureMemoryInfoNV;
+  struct BindBufferMemoryInfo;
+  using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
+  struct BindImageMemoryInfo;
+  using BindImageMemoryInfoKHR = BindImageMemoryInfo;
+  struct BindSparseInfo;
+  struct BufferCopy;
+  struct BufferCreateInfo;
+  struct BufferImageCopy;
+  struct BufferMemoryBarrier;
+  struct BufferMemoryRequirementsInfo2;
+  using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
+  struct BufferViewCreateInfo;
+  struct CalibratedTimestampInfoEXT;
+  struct CheckpointDataNV;
+  struct ClearAttachment;
+  union ClearColorValue;
+  struct ClearDepthStencilValue;
+  struct ClearRect;
+  struct CmdProcessCommandsInfoNVX;
+  struct CmdReserveSpaceForCommandsInfoNVX;
+  struct CoarseSampleOrderCustomNV;
+  struct CommandBufferAllocateInfo;
+  struct CommandBufferBeginInfo;
+  struct CommandPoolCreateInfo;
+  struct ComputePipelineCreateInfo;
+  struct ConditionalRenderingBeginInfoEXT;
+  struct CopyDescriptorSet;
+  struct DebugMarkerMarkerInfoEXT;
+  struct DebugMarkerObjectNameInfoEXT;
+  struct DebugMarkerObjectTagInfoEXT;
+  struct DebugReportCallbackCreateInfoEXT;
+  struct DebugUtilsLabelEXT;
+  struct DebugUtilsMessengerCallbackDataEXT;
+  struct DebugUtilsMessengerCreateInfoEXT;
+  struct DebugUtilsObjectNameInfoEXT;
+  struct DebugUtilsObjectTagInfoEXT;
+  struct DescriptorPoolCreateInfo;
+  struct DescriptorSetAllocateInfo;
+  struct DescriptorSetLayoutCreateInfo;
+  struct DescriptorSetLayoutSupport;
+  using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
+  struct DescriptorUpdateTemplateCreateInfo;
+  using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
+  struct DeviceCreateInfo;
+  struct DeviceEventInfoEXT;
+  struct DeviceGeneratedCommandsFeaturesNVX;
+  struct DeviceGeneratedCommandsLimitsNVX;
+  struct DeviceGroupPresentCapabilitiesKHR;
+  struct DeviceQueueInfo2;
+  struct DisplayEventInfoEXT;
+  struct DisplayModeCreateInfoKHR;
+  struct DisplayModeProperties2KHR;
+  struct DisplayModePropertiesKHR;
+  struct DisplayPlaneCapabilities2KHR;
+  struct DisplayPlaneCapabilitiesKHR;
+  struct DisplayPlaneInfo2KHR;
+  struct DisplayPlaneProperties2KHR;
+  struct DisplayPlanePropertiesKHR;
+  struct DisplayPowerInfoEXT;
+  struct DisplayProperties2KHR;
+  struct DisplayPropertiesKHR;
+  struct DisplaySurfaceCreateInfoKHR;
+  struct EventCreateInfo;
+  struct ExtensionProperties;
+  struct Extent2D;
+  struct ExternalBufferProperties;
+  using ExternalBufferPropertiesKHR = ExternalBufferProperties;
+  struct ExternalFenceProperties;
+  using ExternalFencePropertiesKHR = ExternalFenceProperties;
+  struct ExternalImageFormatPropertiesNV;
+  struct ExternalSemaphoreProperties;
+  using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
+  struct FenceCreateInfo;
+  struct FenceGetFdInfoKHR;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct FenceGetWin32HandleInfoKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+  struct FormatProperties;
+  struct FormatProperties2;
+  using FormatProperties2KHR = FormatProperties2;
+  struct FramebufferCreateInfo;
+  struct GraphicsPipelineCreateInfo;
+  struct HdrMetadataEXT;
+#ifdef VK_USE_PLATFORM_IOS_MVK
+  struct IOSSurfaceCreateInfoMVK;
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+  struct ImageBlit;
+  struct ImageCopy;
+  struct ImageCreateInfo;
+  struct ImageDrmFormatModifierPropertiesEXT;
+  struct ImageFormatProperties;
+  struct ImageFormatProperties2;
+  using ImageFormatProperties2KHR = ImageFormatProperties2;
+  struct ImageMemoryBarrier;
+  struct ImageMemoryRequirementsInfo2;
+  using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
+#ifdef VK_USE_PLATFORM_FUCHSIA
+  struct ImagePipeSurfaceCreateInfoFUCHSIA;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+  struct ImageResolve;
+  struct ImageSparseMemoryRequirementsInfo2;
+  using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
+  struct ImageSubresource;
+  struct ImageSubresourceRange;
+  struct ImageViewCreateInfo;
+  struct ImportFenceFdInfoKHR;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct ImportFenceWin32HandleInfoKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+  struct ImportSemaphoreFdInfoKHR;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct ImportSemaphoreWin32HandleInfoKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+  struct IndirectCommandsLayoutCreateInfoNVX;
+  struct InstanceCreateInfo;
+  struct LayerProperties;
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+  struct MacOSSurfaceCreateInfoMVK;
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+  struct MappedMemoryRange;
+  struct MemoryAllocateInfo;
+  struct MemoryBarrier;
+  struct MemoryFdPropertiesKHR;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  struct MemoryGetAndroidHardwareBufferInfoANDROID;
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+  struct MemoryGetFdInfoKHR;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct MemoryGetWin32HandleInfoKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+  struct MemoryHostPointerPropertiesEXT;
+  struct MemoryRequirements;
+  struct MemoryRequirements2;
+  using MemoryRequirements2KHR = MemoryRequirements2;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct MemoryWin32HandlePropertiesKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+  struct MultisamplePropertiesEXT;
+  struct ObjectTableCreateInfoNVX;
+  struct ObjectTableEntryNVX;
+  struct PastPresentationTimingGOOGLE;
+  struct PhysicalDeviceExternalBufferInfo;
+  using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
+  struct PhysicalDeviceExternalFenceInfo;
+  using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
+  struct PhysicalDeviceExternalSemaphoreInfo;
+  using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
+  struct PhysicalDeviceFeatures;
+  struct PhysicalDeviceFeatures2;
+  using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
+  struct PhysicalDeviceGroupProperties;
+  using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
+  struct PhysicalDeviceImageFormatInfo2;
+  using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
+  struct PhysicalDeviceMemoryProperties;
+  struct PhysicalDeviceMemoryProperties2;
+  using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
+  struct PhysicalDeviceProperties;
+  struct PhysicalDeviceProperties2;
+  using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
+  struct PhysicalDeviceSparseImageFormatInfo2;
+  using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
+  struct PhysicalDeviceSurfaceInfo2KHR;
+  struct PipelineCacheCreateInfo;
+  struct PipelineLayoutCreateInfo;
+  struct PresentInfoKHR;
+  struct QueryPoolCreateInfo;
+  struct QueueFamilyProperties;
+  struct QueueFamilyProperties2;
+  using QueueFamilyProperties2KHR = QueueFamilyProperties2;
+  struct RayTracingPipelineCreateInfoNV;
+  struct Rect2D;
+  struct RefreshCycleDurationGOOGLE;
+  struct RenderPassBeginInfo;
+  struct RenderPassCreateInfo;
+  struct RenderPassCreateInfo2KHR;
+  struct SampleLocationsInfoEXT;
+  struct SamplerCreateInfo;
+  struct SamplerYcbcrConversionCreateInfo;
+  using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
+  struct SemaphoreCreateInfo;
+  struct SemaphoreGetFdInfoKHR;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct SemaphoreGetWin32HandleInfoKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+  struct ShaderModuleCreateInfo;
+  struct ShadingRatePaletteNV;
+  struct SparseImageFormatProperties;
+  struct SparseImageFormatProperties2;
+  using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
+  struct SparseImageMemoryRequirements;
+  struct SparseImageMemoryRequirements2;
+  using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
+  struct SubmitInfo;
+  struct SubpassBeginInfoKHR;
+  struct SubpassEndInfoKHR;
+  struct SubresourceLayout;
+  struct SurfaceCapabilities2EXT;
+  struct SurfaceCapabilities2KHR;
+  struct SurfaceCapabilitiesKHR;
+  struct SurfaceFormat2KHR;
+  struct SurfaceFormatKHR;
+  struct SwapchainCreateInfoKHR;
+  struct ValidationCacheCreateInfoEXT;
+#ifdef VK_USE_PLATFORM_VI_NN
+  struct ViSurfaceCreateInfoNN;
+#endif /*VK_USE_PLATFORM_VI_NN*/
+  struct Viewport;
+  struct ViewportWScalingNV;
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+  struct WaylandSurfaceCreateInfoKHR;
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct Win32SurfaceCreateInfoKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+  struct WriteDescriptorSet;
+#ifdef VK_USE_PLATFORM_XCB_KHR
+  struct XcbSurfaceCreateInfoKHR;
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+  struct XlibSurfaceCreateInfoKHR;
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+  class SurfaceKHR
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR SurfaceKHR()
+      : m_surfaceKHR(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t )
+      : m_surfaceKHR(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR )
+      : m_surfaceKHR( surfaceKHR )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR)
+    {
+      m_surfaceKHR = surfaceKHR;
+      return *this; 
+    }
+#endif
+
+    SurfaceKHR & operator=( std::nullptr_t )
+    {
+      m_surfaceKHR = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( SurfaceKHR const & rhs ) const
+    {
+      return m_surfaceKHR == rhs.m_surfaceKHR;
+    }
+
+    bool operator!=(SurfaceKHR const & rhs ) const
+    {
+      return m_surfaceKHR != rhs.m_surfaceKHR;
+    }
+
+    bool operator<(SurfaceKHR const & rhs ) const
+    {
+      return m_surfaceKHR < rhs.m_surfaceKHR;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const
+    {
+      return m_surfaceKHR;
+    }
+
+    explicit operator bool() const
+    {
+      return m_surfaceKHR != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_surfaceKHR == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkSurfaceKHR m_surfaceKHR;
+  };
+  static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" );
+
+  class DebugReportCallbackEXT
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT()
+      : m_debugReportCallbackEXT(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t )
+      : m_debugReportCallbackEXT(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT )
+      : m_debugReportCallbackEXT( debugReportCallbackEXT )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT)
+    {
+      m_debugReportCallbackEXT = debugReportCallbackEXT;
+      return *this; 
+    }
+#endif
+
+    DebugReportCallbackEXT & operator=( std::nullptr_t )
+    {
+      m_debugReportCallbackEXT = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( DebugReportCallbackEXT const & rhs ) const
+    {
+      return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
+    }
+
+    bool operator!=(DebugReportCallbackEXT const & rhs ) const
+    {
+      return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
+    }
+
+    bool operator<(DebugReportCallbackEXT const & rhs ) const
+    {
+      return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const
+    {
+      return m_debugReportCallbackEXT;
+    }
+
+    explicit operator bool() const
+    {
+      return m_debugReportCallbackEXT != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_debugReportCallbackEXT == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkDebugReportCallbackEXT m_debugReportCallbackEXT;
+  };
+  static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" );
+
+  class DebugUtilsMessengerEXT
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT()
+      : m_debugUtilsMessengerEXT(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t )
+      : m_debugUtilsMessengerEXT(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT )
+      : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    DebugUtilsMessengerEXT & operator=(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)
+    {
+      m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
+      return *this; 
+    }
+#endif
+
+    DebugUtilsMessengerEXT & operator=( std::nullptr_t )
+    {
+      m_debugUtilsMessengerEXT = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( DebugUtilsMessengerEXT const & rhs ) const
+    {
+      return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
+    }
+
+    bool operator!=(DebugUtilsMessengerEXT const & rhs ) const
+    {
+      return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
+    }
+
+    bool operator<(DebugUtilsMessengerEXT const & rhs ) const
+    {
+      return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const
+    {
+      return m_debugUtilsMessengerEXT;
+    }
+
+    explicit operator bool() const
+    {
+      return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT;
+  };
+  static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" );
+
+  class DisplayKHR
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR DisplayKHR()
+      : m_displayKHR(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t )
+      : m_displayKHR(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR )
+      : m_displayKHR( displayKHR )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    DisplayKHR & operator=(VkDisplayKHR displayKHR)
+    {
+      m_displayKHR = displayKHR;
+      return *this; 
+    }
+#endif
+
+    DisplayKHR & operator=( std::nullptr_t )
+    {
+      m_displayKHR = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( DisplayKHR const & rhs ) const
+    {
+      return m_displayKHR == rhs.m_displayKHR;
+    }
+
+    bool operator!=(DisplayKHR const & rhs ) const
+    {
+      return m_displayKHR != rhs.m_displayKHR;
+    }
+
+    bool operator<(DisplayKHR const & rhs ) const
+    {
+      return m_displayKHR < rhs.m_displayKHR;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const
+    {
+      return m_displayKHR;
+    }
+
+    explicit operator bool() const
+    {
+      return m_displayKHR != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_displayKHR == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkDisplayKHR m_displayKHR;
+  };
+  static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" );
+
+  class SwapchainKHR
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR SwapchainKHR()
+      : m_swapchainKHR(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t )
+      : m_swapchainKHR(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR )
+      : m_swapchainKHR( swapchainKHR )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR)
+    {
+      m_swapchainKHR = swapchainKHR;
+      return *this; 
+    }
+#endif
+
+    SwapchainKHR & operator=( std::nullptr_t )
+    {
+      m_swapchainKHR = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( SwapchainKHR const & rhs ) const
+    {
+      return m_swapchainKHR == rhs.m_swapchainKHR;
+    }
+
+    bool operator!=(SwapchainKHR const & rhs ) const
+    {
+      return m_swapchainKHR != rhs.m_swapchainKHR;
+    }
+
+    bool operator<(SwapchainKHR const & rhs ) const
+    {
+      return m_swapchainKHR < rhs.m_swapchainKHR;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const
+    {
+      return m_swapchainKHR;
+    }
+
+    explicit operator bool() const
+    {
+      return m_swapchainKHR != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_swapchainKHR == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkSwapchainKHR m_swapchainKHR;
+  };
+  static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" );
+
+  class Semaphore
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR Semaphore()
+      : m_semaphore(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t )
+      : m_semaphore(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore )
+      : m_semaphore( semaphore )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Semaphore & operator=(VkSemaphore semaphore)
+    {
+      m_semaphore = semaphore;
+      return *this; 
+    }
+#endif
+
+    Semaphore & operator=( std::nullptr_t )
+    {
+      m_semaphore = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( Semaphore const & rhs ) const
+    {
+      return m_semaphore == rhs.m_semaphore;
+    }
+
+    bool operator!=(Semaphore const & rhs ) const
+    {
+      return m_semaphore != rhs.m_semaphore;
+    }
+
+    bool operator<(Semaphore const & rhs ) const
+    {
+      return m_semaphore < rhs.m_semaphore;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const
+    {
+      return m_semaphore;
+    }
+
+    explicit operator bool() const
+    {
+      return m_semaphore != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_semaphore == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkSemaphore m_semaphore;
+  };
+  static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" );
+
+  class Fence
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR Fence()
+      : m_fence(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t )
+      : m_fence(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence )
+      : m_fence( fence )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Fence & operator=(VkFence fence)
+    {
+      m_fence = fence;
+      return *this; 
+    }
+#endif
+
+    Fence & operator=( std::nullptr_t )
+    {
+      m_fence = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( Fence const & rhs ) const
+    {
+      return m_fence == rhs.m_fence;
+    }
+
+    bool operator!=(Fence const & rhs ) const
+    {
+      return m_fence != rhs.m_fence;
+    }
+
+    bool operator<(Fence const & rhs ) const
+    {
+      return m_fence < rhs.m_fence;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const
+    {
+      return m_fence;
+    }
+
+    explicit operator bool() const
+    {
+      return m_fence != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_fence == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkFence m_fence;
+  };
+  static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" );
+
+  class QueryPool
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR QueryPool()
+      : m_queryPool(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t )
+      : m_queryPool(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool )
+      : m_queryPool( queryPool )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    QueryPool & operator=(VkQueryPool queryPool)
+    {
+      m_queryPool = queryPool;
+      return *this; 
+    }
+#endif
+
+    QueryPool & operator=( std::nullptr_t )
+    {
+      m_queryPool = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( QueryPool const & rhs ) const
+    {
+      return m_queryPool == rhs.m_queryPool;
+    }
+
+    bool operator!=(QueryPool const & rhs ) const
+    {
+      return m_queryPool != rhs.m_queryPool;
+    }
+
+    bool operator<(QueryPool const & rhs ) const
+    {
+      return m_queryPool < rhs.m_queryPool;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const
+    {
+      return m_queryPool;
+    }
+
+    explicit operator bool() const
+    {
+      return m_queryPool != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_queryPool == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkQueryPool m_queryPool;
+  };
+  static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" );
+
+  class Buffer
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR Buffer()
+      : m_buffer(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t )
+      : m_buffer(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer )
+      : m_buffer( buffer )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Buffer & operator=(VkBuffer buffer)
+    {
+      m_buffer = buffer;
+      return *this; 
+    }
+#endif
+
+    Buffer & operator=( std::nullptr_t )
+    {
+      m_buffer = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( Buffer const & rhs ) const
+    {
+      return m_buffer == rhs.m_buffer;
+    }
+
+    bool operator!=(Buffer const & rhs ) const
+    {
+      return m_buffer != rhs.m_buffer;
+    }
+
+    bool operator<(Buffer const & rhs ) const
+    {
+      return m_buffer < rhs.m_buffer;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const
+    {
+      return m_buffer;
+    }
+
+    explicit operator bool() const
+    {
+      return m_buffer != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_buffer == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkBuffer m_buffer;
+  };
+  static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" );
+
+  class PipelineLayout
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR PipelineLayout()
+      : m_pipelineLayout(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t )
+      : m_pipelineLayout(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout )
+      : m_pipelineLayout( pipelineLayout )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    PipelineLayout & operator=(VkPipelineLayout pipelineLayout)
+    {
+      m_pipelineLayout = pipelineLayout;
+      return *this; 
+    }
+#endif
+
+    PipelineLayout & operator=( std::nullptr_t )
+    {
+      m_pipelineLayout = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( PipelineLayout const & rhs ) const
+    {
+      return m_pipelineLayout == rhs.m_pipelineLayout;
+    }
+
+    bool operator!=(PipelineLayout const & rhs ) const
+    {
+      return m_pipelineLayout != rhs.m_pipelineLayout;
+    }
+
+    bool operator<(PipelineLayout const & rhs ) const
+    {
+      return m_pipelineLayout < rhs.m_pipelineLayout;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const
+    {
+      return m_pipelineLayout;
+    }
+
+    explicit operator bool() const
+    {
+      return m_pipelineLayout != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_pipelineLayout == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkPipelineLayout m_pipelineLayout;
+  };
+  static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" );
+
+  class DescriptorSet
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR DescriptorSet()
+      : m_descriptorSet(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t )
+      : m_descriptorSet(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet )
+      : m_descriptorSet( descriptorSet )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    DescriptorSet & operator=(VkDescriptorSet descriptorSet)
+    {
+      m_descriptorSet = descriptorSet;
+      return *this; 
+    }
+#endif
+
+    DescriptorSet & operator=( std::nullptr_t )
+    {
+      m_descriptorSet = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( DescriptorSet const & rhs ) const
+    {
+      return m_descriptorSet == rhs.m_descriptorSet;
+    }
+
+    bool operator!=(DescriptorSet const & rhs ) const
+    {
+      return m_descriptorSet != rhs.m_descriptorSet;
+    }
+
+    bool operator<(DescriptorSet const & rhs ) const
+    {
+      return m_descriptorSet < rhs.m_descriptorSet;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const
+    {
+      return m_descriptorSet;
+    }
+
+    explicit operator bool() const
+    {
+      return m_descriptorSet != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_descriptorSet == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkDescriptorSet m_descriptorSet;
+  };
+  static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" );
+
+  class Pipeline
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR Pipeline()
+      : m_pipeline(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t )
+      : m_pipeline(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline )
+      : m_pipeline( pipeline )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Pipeline & operator=(VkPipeline pipeline)
+    {
+      m_pipeline = pipeline;
+      return *this; 
+    }
+#endif
+
+    Pipeline & operator=( std::nullptr_t )
+    {
+      m_pipeline = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( Pipeline const & rhs ) const
+    {
+      return m_pipeline == rhs.m_pipeline;
+    }
+
+    bool operator!=(Pipeline const & rhs ) const
+    {
+      return m_pipeline != rhs.m_pipeline;
+    }
+
+    bool operator<(Pipeline const & rhs ) const
+    {
+      return m_pipeline < rhs.m_pipeline;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const
+    {
+      return m_pipeline;
+    }
+
+    explicit operator bool() const
+    {
+      return m_pipeline != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_pipeline == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkPipeline m_pipeline;
+  };
+  static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" );
+
+  class ImageView
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR ImageView()
+      : m_imageView(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t )
+      : m_imageView(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView )
+      : m_imageView( imageView )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    ImageView & operator=(VkImageView imageView)
+    {
+      m_imageView = imageView;
+      return *this; 
+    }
+#endif
+
+    ImageView & operator=( std::nullptr_t )
+    {
+      m_imageView = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( ImageView const & rhs ) const
+    {
+      return m_imageView == rhs.m_imageView;
+    }
+
+    bool operator!=(ImageView const & rhs ) const
+    {
+      return m_imageView != rhs.m_imageView;
+    }
+
+    bool operator<(ImageView const & rhs ) const
+    {
+      return m_imageView < rhs.m_imageView;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const
+    {
+      return m_imageView;
+    }
+
+    explicit operator bool() const
+    {
+      return m_imageView != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_imageView == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkImageView m_imageView;
+  };
+  static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" );
+
+  class Image
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR Image()
+      : m_image(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR Image( std::nullptr_t )
+      : m_image(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image )
+      : m_image( image )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Image & operator=(VkImage image)
+    {
+      m_image = image;
+      return *this; 
+    }
+#endif
+
+    Image & operator=( std::nullptr_t )
+    {
+      m_image = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( Image const & rhs ) const
+    {
+      return m_image == rhs.m_image;
+    }
+
+    bool operator!=(Image const & rhs ) const
+    {
+      return m_image != rhs.m_image;
+    }
+
+    bool operator<(Image const & rhs ) const
+    {
+      return m_image < rhs.m_image;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const
+    {
+      return m_image;
+    }
+
+    explicit operator bool() const
+    {
+      return m_image != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_image == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkImage m_image;
+  };
+  static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" );
+
+  class AccelerationStructureNV
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR AccelerationStructureNV()
+      : m_accelerationStructureNV(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t )
+      : m_accelerationStructureNV(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV )
+      : m_accelerationStructureNV( accelerationStructureNV )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    AccelerationStructureNV & operator=(VkAccelerationStructureNV accelerationStructureNV)
+    {
+      m_accelerationStructureNV = accelerationStructureNV;
+      return *this; 
+    }
+#endif
+
+    AccelerationStructureNV & operator=( std::nullptr_t )
+    {
+      m_accelerationStructureNV = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( AccelerationStructureNV const & rhs ) const
+    {
+      return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
+    }
+
+    bool operator!=(AccelerationStructureNV const & rhs ) const
+    {
+      return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
+    }
+
+    bool operator<(AccelerationStructureNV const & rhs ) const
+    {
+      return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const
+    {
+      return m_accelerationStructureNV;
+    }
+
+    explicit operator bool() const
+    {
+      return m_accelerationStructureNV != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_accelerationStructureNV == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkAccelerationStructureNV m_accelerationStructureNV;
+  };
+  static_assert( sizeof( AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), "handle and wrapper have different size!" );
+
+  class DescriptorUpdateTemplate
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate()
+      : m_descriptorUpdateTemplate(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t )
+      : m_descriptorUpdateTemplate(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate )
+      : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    DescriptorUpdateTemplate & operator=(VkDescriptorUpdateTemplate descriptorUpdateTemplate)
+    {
+      m_descriptorUpdateTemplate = descriptorUpdateTemplate;
+      return *this; 
+    }
+#endif
+
+    DescriptorUpdateTemplate & operator=( std::nullptr_t )
+    {
+      m_descriptorUpdateTemplate = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( DescriptorUpdateTemplate const & rhs ) const
+    {
+      return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
+    }
+
+    bool operator!=(DescriptorUpdateTemplate const & rhs ) const
+    {
+      return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
+    }
+
+    bool operator<(DescriptorUpdateTemplate const & rhs ) const
+    {
+      return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const
+    {
+      return m_descriptorUpdateTemplate;
+    }
+
+    explicit operator bool() const
+    {
+      return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkDescriptorUpdateTemplate m_descriptorUpdateTemplate;
+  };
+  static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" );
+  using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
+
+  class Event
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR Event()
+      : m_event(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR Event( std::nullptr_t )
+      : m_event(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event )
+      : m_event( event )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Event & operator=(VkEvent event)
+    {
+      m_event = event;
+      return *this; 
+    }
+#endif
+
+    Event & operator=( std::nullptr_t )
+    {
+      m_event = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( Event const & rhs ) const
+    {
+      return m_event == rhs.m_event;
+    }
+
+    bool operator!=(Event const & rhs ) const
+    {
+      return m_event != rhs.m_event;
+    }
+
+    bool operator<(Event const & rhs ) const
+    {
+      return m_event < rhs.m_event;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const
+    {
+      return m_event;
+    }
+
+    explicit operator bool() const
+    {
+      return m_event != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_event == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkEvent m_event;
+  };
+  static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" );
+
+  class CommandBuffer
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR CommandBuffer()
+      : m_commandBuffer(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t )
+      : m_commandBuffer(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer )
+      : m_commandBuffer( commandBuffer )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    CommandBuffer & operator=(VkCommandBuffer commandBuffer)
+    {
+      m_commandBuffer = commandBuffer;
+      return *this; 
+    }
+#endif
+
+    CommandBuffer & operator=( std::nullptr_t )
+    {
+      m_commandBuffer = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( CommandBuffer const & rhs ) const
+    {
+      return m_commandBuffer == rhs.m_commandBuffer;
+    }
+
+    bool operator!=(CommandBuffer const & rhs ) const
+    {
+      return m_commandBuffer != rhs.m_commandBuffer;
+    }
+
+    bool operator<(CommandBuffer const & rhs ) const
+    {
+      return m_commandBuffer < rhs.m_commandBuffer;
+    }
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result begin( const CommandBufferBeginInfo* pBeginInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type begin( const CommandBufferBeginInfo & beginInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginRenderPass2KHR( const RenderPassBeginInfo* pRenderPassBegin, const SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfoKHR & subpassBeginInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy<const DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, ArrayProxy<const DeviceSize> sizes, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageBlit> regions, Filter filter, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void clearAttachments( ArrayProxy<const ClearAttachment> attachments, ArrayProxy<const ClearRect> rects, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void debugMarkerEndEXT(Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void endConditionalRenderingEXT(Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void endRenderPass(Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void endRenderPass2KHR( const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void endRenderPass2KHR( const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void executeCommands( ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void nextSubpass( SubpassContents contents, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void nextSubpass2KHR( const SubpassBeginInfoKHR* pSubpassBeginInfo, const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void nextSubpass2KHR( const SubpassBeginInfoKHR & subpassBeginInfo, const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename T, typename Dispatch = DispatchLoaderStatic>
+    void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setBlendConstants( const float blendConstants[4], Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setDeviceMask( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setLineWidth( float lineWidth, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename T, typename Dispatch = DispatchLoaderStatic>
+    void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void writeAccelerationStructuresPropertiesNV( ArrayProxy<const AccelerationStructureNV> accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const;
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result end(Dispatch const &d = Dispatch() ) const;
+#else
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type end(Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const;
+#else
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const
+    {
+      return m_commandBuffer;
+    }
+
+    explicit operator bool() const
+    {
+      return m_commandBuffer != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_commandBuffer == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkCommandBuffer m_commandBuffer;
+  };
+  static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" );
+
+  class DeviceMemory
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR DeviceMemory()
+      : m_deviceMemory(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t )
+      : m_deviceMemory(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory )
+      : m_deviceMemory( deviceMemory )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    DeviceMemory & operator=(VkDeviceMemory deviceMemory)
+    {
+      m_deviceMemory = deviceMemory;
+      return *this; 
+    }
+#endif
+
+    DeviceMemory & operator=( std::nullptr_t )
+    {
+      m_deviceMemory = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( DeviceMemory const & rhs ) const
+    {
+      return m_deviceMemory == rhs.m_deviceMemory;
+    }
+
+    bool operator!=(DeviceMemory const & rhs ) const
+    {
+      return m_deviceMemory != rhs.m_deviceMemory;
+    }
+
+    bool operator<(DeviceMemory const & rhs ) const
+    {
+      return m_deviceMemory < rhs.m_deviceMemory;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const
+    {
+      return m_deviceMemory;
+    }
+
+    explicit operator bool() const
+    {
+      return m_deviceMemory != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_deviceMemory == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkDeviceMemory m_deviceMemory;
+  };
+  static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" );
+
+  class BufferView
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR BufferView()
+      : m_bufferView(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t )
+      : m_bufferView(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView )
+      : m_bufferView( bufferView )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    BufferView & operator=(VkBufferView bufferView)
+    {
+      m_bufferView = bufferView;
+      return *this; 
+    }
+#endif
+
+    BufferView & operator=( std::nullptr_t )
+    {
+      m_bufferView = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( BufferView const & rhs ) const
+    {
+      return m_bufferView == rhs.m_bufferView;
+    }
+
+    bool operator!=(BufferView const & rhs ) const
+    {
+      return m_bufferView != rhs.m_bufferView;
+    }
+
+    bool operator<(BufferView const & rhs ) const
+    {
+      return m_bufferView < rhs.m_bufferView;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const
+    {
+      return m_bufferView;
+    }
+
+    explicit operator bool() const
+    {
+      return m_bufferView != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_bufferView == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkBufferView m_bufferView;
+  };
+  static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" );
+
+  class CommandPool
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR CommandPool()
+      : m_commandPool(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t )
+      : m_commandPool(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool )
+      : m_commandPool( commandPool )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    CommandPool & operator=(VkCommandPool commandPool)
+    {
+      m_commandPool = commandPool;
+      return *this; 
+    }
+#endif
+
+    CommandPool & operator=( std::nullptr_t )
+    {
+      m_commandPool = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( CommandPool const & rhs ) const
+    {
+      return m_commandPool == rhs.m_commandPool;
+    }
+
+    bool operator!=(CommandPool const & rhs ) const
+    {
+      return m_commandPool != rhs.m_commandPool;
+    }
+
+    bool operator<(CommandPool const & rhs ) const
+    {
+      return m_commandPool < rhs.m_commandPool;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const
+    {
+      return m_commandPool;
+    }
+
+    explicit operator bool() const
+    {
+      return m_commandPool != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_commandPool == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkCommandPool m_commandPool;
+  };
+  static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" );
+
+  class PipelineCache
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR PipelineCache()
+      : m_pipelineCache(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t )
+      : m_pipelineCache(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache )
+      : m_pipelineCache( pipelineCache )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    PipelineCache & operator=(VkPipelineCache pipelineCache)
+    {
+      m_pipelineCache = pipelineCache;
+      return *this; 
+    }
+#endif
+
+    PipelineCache & operator=( std::nullptr_t )
+    {
+      m_pipelineCache = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( PipelineCache const & rhs ) const
+    {
+      return m_pipelineCache == rhs.m_pipelineCache;
+    }
+
+    bool operator!=(PipelineCache const & rhs ) const
+    {
+      return m_pipelineCache != rhs.m_pipelineCache;
+    }
+
+    bool operator<(PipelineCache const & rhs ) const
+    {
+      return m_pipelineCache < rhs.m_pipelineCache;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const
+    {
+      return m_pipelineCache;
+    }
+
+    explicit operator bool() const
+    {
+      return m_pipelineCache != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_pipelineCache == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkPipelineCache m_pipelineCache;
+  };
+  static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" );
+
+  class DescriptorPool
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR DescriptorPool()
+      : m_descriptorPool(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t )
+      : m_descriptorPool(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool )
+      : m_descriptorPool( descriptorPool )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    DescriptorPool & operator=(VkDescriptorPool descriptorPool)
+    {
+      m_descriptorPool = descriptorPool;
+      return *this; 
+    }
+#endif
+
+    DescriptorPool & operator=( std::nullptr_t )
+    {
+      m_descriptorPool = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( DescriptorPool const & rhs ) const
+    {
+      return m_descriptorPool == rhs.m_descriptorPool;
+    }
+
+    bool operator!=(DescriptorPool const & rhs ) const
+    {
+      return m_descriptorPool != rhs.m_descriptorPool;
+    }
+
+    bool operator<(DescriptorPool const & rhs ) const
+    {
+      return m_descriptorPool < rhs.m_descriptorPool;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const
+    {
+      return m_descriptorPool;
+    }
+
+    explicit operator bool() const
+    {
+      return m_descriptorPool != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_descriptorPool == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkDescriptorPool m_descriptorPool;
+  };
+  static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" );
+
+  class DescriptorSetLayout
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR DescriptorSetLayout()
+      : m_descriptorSetLayout(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t )
+      : m_descriptorSetLayout(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout )
+      : m_descriptorSetLayout( descriptorSetLayout )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout)
+    {
+      m_descriptorSetLayout = descriptorSetLayout;
+      return *this; 
+    }
+#endif
+
+    DescriptorSetLayout & operator=( std::nullptr_t )
+    {
+      m_descriptorSetLayout = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( DescriptorSetLayout const & rhs ) const
+    {
+      return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
+    }
+
+    bool operator!=(DescriptorSetLayout const & rhs ) const
+    {
+      return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
+    }
+
+    bool operator<(DescriptorSetLayout const & rhs ) const
+    {
+      return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const
+    {
+      return m_descriptorSetLayout;
+    }
+
+    explicit operator bool() const
+    {
+      return m_descriptorSetLayout != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_descriptorSetLayout == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkDescriptorSetLayout m_descriptorSetLayout;
+  };
+  static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" );
+
+  class Framebuffer
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR Framebuffer()
+      : m_framebuffer(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t )
+      : m_framebuffer(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer )
+      : m_framebuffer( framebuffer )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Framebuffer & operator=(VkFramebuffer framebuffer)
+    {
+      m_framebuffer = framebuffer;
+      return *this; 
+    }
+#endif
+
+    Framebuffer & operator=( std::nullptr_t )
+    {
+      m_framebuffer = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( Framebuffer const & rhs ) const
+    {
+      return m_framebuffer == rhs.m_framebuffer;
+    }
+
+    bool operator!=(Framebuffer const & rhs ) const
+    {
+      return m_framebuffer != rhs.m_framebuffer;
+    }
+
+    bool operator<(Framebuffer const & rhs ) const
+    {
+      return m_framebuffer < rhs.m_framebuffer;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const
+    {
+      return m_framebuffer;
+    }
+
+    explicit operator bool() const
+    {
+      return m_framebuffer != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_framebuffer == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkFramebuffer m_framebuffer;
+  };
+  static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" );
+
+  class IndirectCommandsLayoutNVX
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX()
+      : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX( std::nullptr_t )
+      : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX( VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX )
+      : m_indirectCommandsLayoutNVX( indirectCommandsLayoutNVX )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    IndirectCommandsLayoutNVX & operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX)
+    {
+      m_indirectCommandsLayoutNVX = indirectCommandsLayoutNVX;
+      return *this; 
+    }
+#endif
+
+    IndirectCommandsLayoutNVX & operator=( std::nullptr_t )
+    {
+      m_indirectCommandsLayoutNVX = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( IndirectCommandsLayoutNVX const & rhs ) const
+    {
+      return m_indirectCommandsLayoutNVX == rhs.m_indirectCommandsLayoutNVX;
+    }
+
+    bool operator!=(IndirectCommandsLayoutNVX const & rhs ) const
+    {
+      return m_indirectCommandsLayoutNVX != rhs.m_indirectCommandsLayoutNVX;
+    }
+
+    bool operator<(IndirectCommandsLayoutNVX const & rhs ) const
+    {
+      return m_indirectCommandsLayoutNVX < rhs.m_indirectCommandsLayoutNVX;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNVX() const
+    {
+      return m_indirectCommandsLayoutNVX;
+    }
+
+    explicit operator bool() const
+    {
+      return m_indirectCommandsLayoutNVX != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_indirectCommandsLayoutNVX == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkIndirectCommandsLayoutNVX m_indirectCommandsLayoutNVX;
+  };
+  static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" );
+
+  class ObjectTableNVX
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR ObjectTableNVX()
+      : m_objectTableNVX(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR ObjectTableNVX( std::nullptr_t )
+      : m_objectTableNVX(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX( VkObjectTableNVX objectTableNVX )
+      : m_objectTableNVX( objectTableNVX )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    ObjectTableNVX & operator=(VkObjectTableNVX objectTableNVX)
+    {
+      m_objectTableNVX = objectTableNVX;
+      return *this; 
+    }
+#endif
+
+    ObjectTableNVX & operator=( std::nullptr_t )
+    {
+      m_objectTableNVX = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( ObjectTableNVX const & rhs ) const
+    {
+      return m_objectTableNVX == rhs.m_objectTableNVX;
+    }
+
+    bool operator!=(ObjectTableNVX const & rhs ) const
+    {
+      return m_objectTableNVX != rhs.m_objectTableNVX;
+    }
+
+    bool operator<(ObjectTableNVX const & rhs ) const
+    {
+      return m_objectTableNVX < rhs.m_objectTableNVX;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkObjectTableNVX() const
+    {
+      return m_objectTableNVX;
+    }
+
+    explicit operator bool() const
+    {
+      return m_objectTableNVX != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_objectTableNVX == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkObjectTableNVX m_objectTableNVX;
+  };
+  static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" );
+
+  class RenderPass
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR RenderPass()
+      : m_renderPass(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t )
+      : m_renderPass(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass )
+      : m_renderPass( renderPass )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    RenderPass & operator=(VkRenderPass renderPass)
+    {
+      m_renderPass = renderPass;
+      return *this; 
+    }
+#endif
+
+    RenderPass & operator=( std::nullptr_t )
+    {
+      m_renderPass = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( RenderPass const & rhs ) const
+    {
+      return m_renderPass == rhs.m_renderPass;
+    }
+
+    bool operator!=(RenderPass const & rhs ) const
+    {
+      return m_renderPass != rhs.m_renderPass;
+    }
+
+    bool operator<(RenderPass const & rhs ) const
+    {
+      return m_renderPass < rhs.m_renderPass;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const
+    {
+      return m_renderPass;
+    }
+
+    explicit operator bool() const
+    {
+      return m_renderPass != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_renderPass == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkRenderPass m_renderPass;
+  };
+  static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" );
+
+  class Sampler
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR Sampler()
+      : m_sampler(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t )
+      : m_sampler(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler )
+      : m_sampler( sampler )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Sampler & operator=(VkSampler sampler)
+    {
+      m_sampler = sampler;
+      return *this; 
+    }
+#endif
+
+    Sampler & operator=( std::nullptr_t )
+    {
+      m_sampler = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( Sampler const & rhs ) const
+    {
+      return m_sampler == rhs.m_sampler;
+    }
+
+    bool operator!=(Sampler const & rhs ) const
+    {
+      return m_sampler != rhs.m_sampler;
+    }
+
+    bool operator<(Sampler const & rhs ) const
+    {
+      return m_sampler < rhs.m_sampler;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const
+    {
+      return m_sampler;
+    }
+
+    explicit operator bool() const
+    {
+      return m_sampler != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_sampler == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkSampler m_sampler;
+  };
+  static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" );
+
+  class SamplerYcbcrConversion
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion()
+      : m_samplerYcbcrConversion(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t )
+      : m_samplerYcbcrConversion(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion )
+      : m_samplerYcbcrConversion( samplerYcbcrConversion )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    SamplerYcbcrConversion & operator=(VkSamplerYcbcrConversion samplerYcbcrConversion)
+    {
+      m_samplerYcbcrConversion = samplerYcbcrConversion;
+      return *this; 
+    }
+#endif
+
+    SamplerYcbcrConversion & operator=( std::nullptr_t )
+    {
+      m_samplerYcbcrConversion = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( SamplerYcbcrConversion const & rhs ) const
+    {
+      return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
+    }
+
+    bool operator!=(SamplerYcbcrConversion const & rhs ) const
+    {
+      return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
+    }
+
+    bool operator<(SamplerYcbcrConversion const & rhs ) const
+    {
+      return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const
+    {
+      return m_samplerYcbcrConversion;
+    }
+
+    explicit operator bool() const
+    {
+      return m_samplerYcbcrConversion != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_samplerYcbcrConversion == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkSamplerYcbcrConversion m_samplerYcbcrConversion;
+  };
+  static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" );
+  using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
+
+  class ShaderModule
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR ShaderModule()
+      : m_shaderModule(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t )
+      : m_shaderModule(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule )
+      : m_shaderModule( shaderModule )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    ShaderModule & operator=(VkShaderModule shaderModule)
+    {
+      m_shaderModule = shaderModule;
+      return *this; 
+    }
+#endif
+
+    ShaderModule & operator=( std::nullptr_t )
+    {
+      m_shaderModule = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( ShaderModule const & rhs ) const
+    {
+      return m_shaderModule == rhs.m_shaderModule;
+    }
+
+    bool operator!=(ShaderModule const & rhs ) const
+    {
+      return m_shaderModule != rhs.m_shaderModule;
+    }
+
+    bool operator<(ShaderModule const & rhs ) const
+    {
+      return m_shaderModule < rhs.m_shaderModule;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const
+    {
+      return m_shaderModule;
+    }
+
+    explicit operator bool() const
+    {
+      return m_shaderModule != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_shaderModule == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkShaderModule m_shaderModule;
+  };
+  static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" );
+
+  class ValidationCacheEXT
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR ValidationCacheEXT()
+      : m_validationCacheEXT(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t )
+      : m_validationCacheEXT(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT )
+      : m_validationCacheEXT( validationCacheEXT )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    ValidationCacheEXT & operator=(VkValidationCacheEXT validationCacheEXT)
+    {
+      m_validationCacheEXT = validationCacheEXT;
+      return *this; 
+    }
+#endif
+
+    ValidationCacheEXT & operator=( std::nullptr_t )
+    {
+      m_validationCacheEXT = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( ValidationCacheEXT const & rhs ) const
+    {
+      return m_validationCacheEXT == rhs.m_validationCacheEXT;
+    }
+
+    bool operator!=(ValidationCacheEXT const & rhs ) const
+    {
+      return m_validationCacheEXT != rhs.m_validationCacheEXT;
+    }
+
+    bool operator<(ValidationCacheEXT const & rhs ) const
+    {
+      return m_validationCacheEXT < rhs.m_validationCacheEXT;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const
+    {
+      return m_validationCacheEXT;
+    }
+
+    explicit operator bool() const
+    {
+      return m_validationCacheEXT != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_validationCacheEXT == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkValidationCacheEXT m_validationCacheEXT;
+  };
+  static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" );
+
+  class Queue
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR Queue()
+      : m_queue(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t )
+      : m_queue(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue )
+      : m_queue( queue )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Queue & operator=(VkQueue queue)
+    {
+      m_queue = queue;
+      return *this; 
+    }
+#endif
+
+    Queue & operator=( std::nullptr_t )
+    {
+      m_queue = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( Queue const & rhs ) const
+    {
+      return m_queue == rhs.m_queue;
+    }
+
+    bool operator!=(Queue const & rhs ) const
+    {
+      return m_queue != rhs.m_queue;
+    }
+
+    bool operator<(Queue const & rhs ) const
+    {
+      return m_queue < rhs.m_queue;
+    }
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getCheckpointDataNV( uint32_t* pCheckpointDataCount, CheckpointDataNV* pCheckpointData, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<CheckpointDataNV>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<CheckpointDataNV,Allocator> getCheckpointDataNV(Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<CheckpointDataNV>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<CheckpointDataNV,Allocator> getCheckpointDataNV(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type submit( ArrayProxy<const SubmitInfo> submits, Fence fence, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result waitIdle(Dispatch const &d = Dispatch() ) const;
+#else
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type waitIdle(Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const
+    {
+      return m_queue;
+    }
+
+    explicit operator bool() const
+    {
+      return m_queue != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_queue == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkQueue m_queue;
+  };
+  static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" );
+
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  class Device;
+  template <typename Dispatch> class UniqueHandleTraits<AccelerationStructureNV, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<Buffer, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueBuffer = UniqueHandle<Buffer, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<BufferView, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueBufferView = UniqueHandle<BufferView, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<CommandBuffer, Dispatch> { public: using deleter = PoolFree<Device, CommandPool, Dispatch>; };
+  using UniqueCommandBuffer = UniqueHandle<CommandBuffer, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<CommandPool, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueCommandPool = UniqueHandle<CommandPool, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<DescriptorPool, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueDescriptorPool = UniqueHandle<DescriptorPool, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<DescriptorSet, Dispatch> { public: using deleter = PoolFree<Device, DescriptorPool, Dispatch>; };
+  using UniqueDescriptorSet = UniqueHandle<DescriptorSet, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<DescriptorSetLayout, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueDescriptorUpdateTemplate = UniqueHandle<DescriptorUpdateTemplate, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<DeviceMemory, Dispatch> { public: using deleter = ObjectFree<Device, Dispatch>; };
+  using UniqueDeviceMemory = UniqueHandle<DeviceMemory, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<Event, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueEvent = UniqueHandle<Event, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<Fence, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueFence = UniqueHandle<Fence, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<Framebuffer, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueFramebuffer = UniqueHandle<Framebuffer, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<Image, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueImage = UniqueHandle<Image, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<ImageView, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueImageView = UniqueHandle<ImageView, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<IndirectCommandsLayoutNVX, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueIndirectCommandsLayoutNVX = UniqueHandle<IndirectCommandsLayoutNVX, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<ObjectTableNVX, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueObjectTableNVX = UniqueHandle<ObjectTableNVX, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<Pipeline, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniquePipeline = UniqueHandle<Pipeline, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<PipelineCache, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniquePipelineCache = UniqueHandle<PipelineCache, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<PipelineLayout, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniquePipelineLayout = UniqueHandle<PipelineLayout, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<QueryPool, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueQueryPool = UniqueHandle<QueryPool, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<RenderPass, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueRenderPass = UniqueHandle<RenderPass, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<Sampler, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueSampler = UniqueHandle<Sampler, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<Semaphore, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueSemaphore = UniqueHandle<Semaphore, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<ShaderModule, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueShaderModule = UniqueHandle<ShaderModule, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<SwapchainKHR, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<ValidationCacheEXT, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
+  using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, DispatchLoaderStatic>;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+
+  class Device
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR Device()
+      : m_device(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR Device( std::nullptr_t )
+      : m_device(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device )
+      : m_device( device )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Device & operator=(VkDevice device)
+    {
+      m_device = device;
+      return *this; 
+    }
+#endif
+
+    Device & operator=( std::nullptr_t )
+    {
+      m_device = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( Device const & rhs ) const
+    {
+      return m_device == rhs.m_device;
+    }
+
+    bool operator!=(Device const & rhs ) const
+    {
+      return m_device != rhs.m_device;
+    }
+
+    bool operator<(Device const & rhs ) const
+    {
+      return m_device < rhs.m_device;
+    }
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValue<uint32_t> acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValue<uint32_t> acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Allocator = std::allocator<UniqueCommandBuffer>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<UniqueCommandBuffer>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<DescriptorSet>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<DescriptorSet>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Allocator = std::allocator<UniqueDescriptorSet>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<UniqueDescriptorSet>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<DeviceMemory>::type allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<DeviceMemory,Dispatch>>::type allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type bindAccelerationStructureMemoryNV( ArrayProxy<const BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
+#else
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result bindBufferMemory2( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type bindBufferMemory2( ArrayProxy<const BindBufferMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type bindBufferMemory2KHR( ArrayProxy<const BindBufferMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
+#else
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result bindImageMemory2( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type bindImageMemory2( ArrayProxy<const BindImageMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type bindImageMemory2KHR( ArrayProxy<const BindImageMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
+#else
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<AccelerationStructureNV>::type createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<AccelerationStructureNV,Dispatch>>::type createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Buffer>::type createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<Buffer,Dispatch>>::type createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<BufferView>::type createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<BufferView,Dispatch>>::type createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<CommandPool>::type createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<CommandPool,Dispatch>>::type createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Pipeline>::type createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<DescriptorPool>::type createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<DescriptorPool,Dispatch>>::type createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<DescriptorSetLayout>::type createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<DescriptorSetLayout,Dispatch>>::type createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<DescriptorUpdateTemplate>::type createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<DescriptorUpdateTemplate>::type createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Event>::type createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<Event,Dispatch>>::type createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Fence>::type createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Framebuffer>::type createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<Framebuffer,Dispatch>>::type createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Pipeline>::type createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Image>::type createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<Image,Dispatch>>::type createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<ImageView>::type createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<ImageView,Dispatch>>::type createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<IndirectCommandsLayoutNVX>::type createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNVX,Dispatch>>::type createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<ObjectTableNVX>::type createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<ObjectTableNVX,Dispatch>>::type createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<PipelineCache>::type createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<PipelineCache,Dispatch>>::type createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<PipelineLayout>::type createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<PipelineLayout,Dispatch>>::type createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<QueryPool>::type createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<QueryPool,Dispatch>>::type createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Pipeline>::type createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<RenderPass>::type createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createRenderPass2KHR( const RenderPassCreateInfo2KHR* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<RenderPass>::type createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type createRenderPass2KHRUnique( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Sampler>::type createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<Sampler,Dispatch>>::type createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SamplerYcbcrConversion>::type createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SamplerYcbcrConversion>::type createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Semaphore>::type createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<Semaphore,Dispatch>>::type createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<ShaderModule>::type createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<ShaderModule,Dispatch>>::type createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SwapchainKHR>::type createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<ValidationCacheEXT>::type createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<ValidationCacheEXT,Dispatch>>::type createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyEvent( Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyImage( Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyObjectTableNVX( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result waitIdle(Dispatch const &d = Dispatch() ) const;
+#else
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type waitIdle(Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void free( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type free( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void free( DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename T, typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<StructureChain<X, Y, Z...>>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    MemoryRequirements getBufferMemoryRequirements( Buffer buffer, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    MemoryRequirements2 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    MemoryRequirements2 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<uint64_t>::type getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<DeviceGroupPresentCapabilitiesKHR>::type getGroupPresentCapabilitiesKHR(Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    DeviceSize getMemoryCommitment( DeviceMemory memory, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Queue getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getEventStatus( Event event, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<int>::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getFenceStatus( Fence fence, Dispatch const &d = Dispatch() ) const;
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<HANDLE>::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getImageDrmFormatModifierPropertiesEXT( Image image, ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    MemoryRequirements getImageMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    MemoryRequirements2 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    MemoryRequirements2 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    SubresourceLayout getImageSubresourceLayout( Image image, const ImageSubresource & subresource, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<struct AHardwareBuffer*>::type getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<int>::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<HANDLE>::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<HANDLE>::type getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename T, typename Dispatch = DispatchLoaderStatic>
+    Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename T, typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<RefreshCycleDurationGOOGLE>::type getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Extent2D getRenderAreaGranularity( RenderPass renderPass, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<int>::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<uint64_t>::type getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<Image>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<Image>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void*>::type mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags = MemoryMapFlags(), Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> srcCaches, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Fence>::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Fence>::type registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const;
+#else
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const;
+#else
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result resetEvent( Event event, Dispatch const &d = Dispatch() ) const;
+#else
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type resetEvent( Event event, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type resetFences( ArrayProxy<const Fence> fences, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result setEvent( Event event, Dispatch const &d = Dispatch() ) const;
+#else
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type setEvent( Event event, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> swapchains, ArrayProxy<const HdrMetadataEXT> metadata, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void unmapMemory( DeviceMemory memory, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const;
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const
+    {
+      return m_device;
+    }
+
+    explicit operator bool() const
+    {
+      return m_device != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_device == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkDevice m_device;
+  };
+  static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" );
+
+  class DisplayModeKHR
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR DisplayModeKHR()
+      : m_displayModeKHR(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t )
+      : m_displayModeKHR(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR )
+      : m_displayModeKHR( displayModeKHR )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR)
+    {
+      m_displayModeKHR = displayModeKHR;
+      return *this; 
+    }
+#endif
+
+    DisplayModeKHR & operator=( std::nullptr_t )
+    {
+      m_displayModeKHR = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( DisplayModeKHR const & rhs ) const
+    {
+      return m_displayModeKHR == rhs.m_displayModeKHR;
+    }
+
+    bool operator!=(DisplayModeKHR const & rhs ) const
+    {
+      return m_displayModeKHR != rhs.m_displayModeKHR;
+    }
+
+    bool operator<(DisplayModeKHR const & rhs ) const
+    {
+      return m_displayModeKHR < rhs.m_displayModeKHR;
+    }
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const
+    {
+      return m_displayModeKHR;
+    }
+
+    explicit operator bool() const
+    {
+      return m_displayModeKHR != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_displayModeKHR == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkDisplayModeKHR m_displayModeKHR;
+  };
+  static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" );
+
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch> class UniqueHandleTraits<Device, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; };
+  using UniqueDevice = UniqueHandle<Device, DispatchLoaderStatic>;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+
+  class PhysicalDevice
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR PhysicalDevice()
+      : m_physicalDevice(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t )
+      : m_physicalDevice(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice )
+      : m_physicalDevice( physicalDevice )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    PhysicalDevice & operator=(VkPhysicalDevice physicalDevice)
+    {
+      m_physicalDevice = physicalDevice;
+      return *this; 
+    }
+#endif
+
+    PhysicalDevice & operator=( std::nullptr_t )
+    {
+      m_physicalDevice = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( PhysicalDevice const & rhs ) const
+    {
+      return m_physicalDevice == rhs.m_physicalDevice;
+    }
+
+    bool operator!=(PhysicalDevice const & rhs ) const
+    {
+      return m_physicalDevice != rhs.m_physicalDevice;
+    }
+
+    bool operator<(PhysicalDevice const & rhs ) const
+    {
+      return m_physicalDevice < rhs.m_physicalDevice;
+    }
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Display>::type acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Device>::type createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<Device,Dispatch>>::type createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<DisplayModeKHR>::type createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName = nullptr, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties(Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getDisplayModeProperties2KHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModeProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR* pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<DisplayPlaneCapabilities2KHR>::type getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<TimeDomainEXT>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type getCalibrateableTimeDomainsEXT(Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<TimeDomainEXT>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type getCalibrateableTimeDomainsEXT(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, DisplayPlaneProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<DisplayPlaneProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type getDisplayPlaneProperties2KHR(Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<DisplayPlaneProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type getDisplayPlaneProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<DisplayPlanePropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR(Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<DisplayPlanePropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getDisplayProperties2KHR( uint32_t* pPropertyCount, DisplayProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<DisplayProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type getDisplayProperties2KHR(Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<DisplayProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type getDisplayProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<DisplayPropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR(Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<DisplayPropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ExternalBufferProperties getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ExternalBufferProperties getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ExternalFenceProperties getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ExternalFenceProperties getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<ExternalImageFormatPropertiesNV>::type getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ExternalSemaphoreProperties getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getFeatures( PhysicalDeviceFeatures* pFeatures, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    PhysicalDeviceFeatures getFeatures(Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getFeatures2( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getFeatures2(Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getFeatures2KHR( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getFormatProperties( Format format, FormatProperties* pFormatProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    FormatProperties getFormatProperties( Format format, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getFormatProperties2( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    FormatProperties2 getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getFormatProperties2KHR( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    FormatProperties2 getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    DeviceGeneratedCommandsLimitsNVX getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<ImageFormatProperties>::type getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<ImageFormatProperties2>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<ImageFormatProperties2>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    PhysicalDeviceMemoryProperties getMemoryProperties(Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    MultisamplePropertiesEXT getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getPresentRectanglesKHR( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<Rect2D>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<Rect2D>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getProperties( PhysicalDeviceProperties* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    PhysicalDeviceProperties getProperties(Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getProperties(Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getProperties2( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    PhysicalDeviceProperties2 getProperties2(Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getProperties2(Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getProperties2KHR( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    StructureChain<X, Y, Z...> getProperties2KHR(Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties(Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2(Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const;
+    template<typename StructureChain, typename Allocator = std::allocator<StructureChain>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<StructureChain,Allocator> getQueueFamilyProperties2(Dispatch const &d = Dispatch() ) const;
+    template<typename StructureChain, typename Allocator = std::allocator<StructureChain>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<StructureChain,Allocator> getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2KHR(Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
+    template<typename StructureChain, typename Allocator = std::allocator<StructureChain>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<StructureChain,Allocator> getQueueFamilyProperties2KHR(Dispatch const &d = Dispatch() ) const;
+    template<typename StructureChain, typename Allocator = std::allocator<StructureChain>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<StructureChain,Allocator> getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic>
+    std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SurfaceCapabilities2EXT>::type getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<StructureChain<X, Y, Z...>>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SurfaceCapabilitiesKHR>::type getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<SurfaceFormat2KHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<SurfaceFormat2KHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<Bool32>::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d = Dispatch() ) const;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<DisplayKHR>::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+#else
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<void>::type releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const
+    {
+      return m_physicalDevice;
+    }
+
+    explicit operator bool() const
+    {
+      return m_physicalDevice != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_physicalDevice == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkPhysicalDevice m_physicalDevice;
+  };
+  static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" );
+
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  class Instance;
+  template <typename Dispatch> class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch> { public: using deleter = ObjectDestroy<Instance, Dispatch>; };
+  using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch> { public: using deleter = ObjectDestroy<Instance, Dispatch>; };
+  using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, DispatchLoaderStatic>;
+  template <typename Dispatch> class UniqueHandleTraits<SurfaceKHR, Dispatch> { public: using deleter = ObjectDestroy<Instance, Dispatch>; };
+  using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, DispatchLoaderStatic>;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+
+  class Instance
+  {
+  public:
+    VULKAN_HPP_CONSTEXPR Instance()
+      : m_instance(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t )
+      : m_instance(VK_NULL_HANDLE)
+    {}
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance )
+      : m_instance( instance )
+    {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Instance & operator=(VkInstance instance)
+    {
+      m_instance = instance;
+      return *this; 
+    }
+#endif
+
+    Instance & operator=( std::nullptr_t )
+    {
+      m_instance = VK_NULL_HANDLE;
+      return *this;
+    }
+
+    bool operator==( Instance const & rhs ) const
+    {
+      return m_instance == rhs.m_instance;
+    }
+
+    bool operator!=(Instance const & rhs ) const
+    {
+      return m_instance != rhs.m_instance;
+    }
+
+    bool operator<(Instance const & rhs ) const
+    {
+      return m_instance < rhs.m_instance;
+    }
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SurfaceKHR>::type createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<DebugReportCallbackEXT>::type createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<DebugReportCallbackEXT,Dispatch>>::type createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugUtilsMessengerEXT* pMessenger, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT,Dispatch>>::type createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SurfaceKHR>::type createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SurfaceKHR>::type createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SurfaceKHR>::type createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SurfaceKHR>::type createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
+#ifdef VK_USE_PLATFORM_VI_NN
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SurfaceKHR>::type createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_VI_NN*/
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SurfaceKHR>::type createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SurfaceKHR>::type createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SurfaceKHR>::type createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    ResultValueType<SurfaceKHR>::type createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void destroy( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroups(Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroups(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroupsKHR(Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroupsKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    Result enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Allocator = std::allocator<PhysicalDevice>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices(Dispatch const &d = Dispatch() ) const;
+    template<typename Allocator = std::allocator<PhysicalDevice>, typename Dispatch = DispatchLoaderStatic>
+    typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices(Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    template<typename Dispatch = DispatchLoaderStatic>
+    void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d = Dispatch() ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename Dispatch = DispatchLoaderStatic>
+    void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d = Dispatch() ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const
+    {
+      return m_instance;
+    }
+
+    explicit operator bool() const
+    {
+      return m_instance != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const
+    {
+      return m_instance == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkInstance m_instance;
+  };
+  static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" );
+
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch> class UniqueHandleTraits<Instance, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; };
+  using UniqueInstance = UniqueHandle<Instance, DispatchLoaderStatic>;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+
+  template<typename Dispatch = DispatchLoaderStatic>
+  Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d = Dispatch() );
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch = DispatchLoaderStatic>
+  ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() );
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch = DispatchLoaderStatic>
+  typename ResultValueType<UniqueHandle<Instance,Dispatch>>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() );
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch = DispatchLoaderStatic>
+  Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() );
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic>
+  typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName = nullptr, Dispatch const &d = Dispatch() );
+  template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic>
+  typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d );
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch = DispatchLoaderStatic>
+  Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() );
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic>
+  typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Dispatch const &d = Dispatch() );
+  template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic>
+  typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d );
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch = DispatchLoaderStatic>
+  Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d = Dispatch() );
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch = DispatchLoaderStatic>
+  ResultValueType<uint32_t>::type enumerateInstanceVersion(Dispatch const &d = Dispatch() );
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  struct GeometryTrianglesNV
+  {
+    GeometryTrianglesNV( Buffer vertexData_ = Buffer(),
+                         DeviceSize vertexOffset_ = 0,
+                         uint32_t vertexCount_ = 0,
+                         DeviceSize vertexStride_ = 0,
+                         Format vertexFormat_ = Format::eUndefined,
+                         Buffer indexData_ = Buffer(),
+                         DeviceSize indexOffset_ = 0,
+                         uint32_t indexCount_ = 0,
+                         IndexType indexType_ = IndexType::eUint16,
+                         Buffer transformData_ = Buffer(),
+                         DeviceSize transformOffset_ = 0 )
+      : vertexData( vertexData_ )
+      , vertexOffset( vertexOffset_ )
+      , vertexCount( vertexCount_ )
+      , vertexStride( vertexStride_ )
+      , vertexFormat( vertexFormat_ )
+      , indexData( indexData_ )
+      , indexOffset( indexOffset_ )
+      , indexCount( indexCount_ )
+      , indexType( indexType_ )
+      , transformData( transformData_ )
+      , transformOffset( transformOffset_ )
+    {}
+
+    GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) );
+    }
+
+    GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) );
+      return *this;
+    }
+
+    GeometryTrianglesNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    GeometryTrianglesNV & setVertexData( Buffer vertexData_ )
+    {
+      vertexData = vertexData_;
+      return *this;
+    }
+
+    GeometryTrianglesNV & setVertexOffset( DeviceSize vertexOffset_ )
+    {
+      vertexOffset = vertexOffset_;
+      return *this;
+    }
+
+    GeometryTrianglesNV & setVertexCount( uint32_t vertexCount_ )
+    {
+      vertexCount = vertexCount_;
+      return *this;
+    }
+
+    GeometryTrianglesNV & setVertexStride( DeviceSize vertexStride_ )
+    {
+      vertexStride = vertexStride_;
+      return *this;
+    }
+
+    GeometryTrianglesNV & setVertexFormat( Format vertexFormat_ )
+    {
+      vertexFormat = vertexFormat_;
+      return *this;
+    }
+
+    GeometryTrianglesNV & setIndexData( Buffer indexData_ )
+    {
+      indexData = indexData_;
+      return *this;
+    }
+
+    GeometryTrianglesNV & setIndexOffset( DeviceSize indexOffset_ )
+    {
+      indexOffset = indexOffset_;
+      return *this;
+    }
+
+    GeometryTrianglesNV & setIndexCount( uint32_t indexCount_ )
+    {
+      indexCount = indexCount_;
+      return *this;
+    }
+
+    GeometryTrianglesNV & setIndexType( IndexType indexType_ )
+    {
+      indexType = indexType_;
+      return *this;
+    }
+
+    GeometryTrianglesNV & setTransformData( Buffer transformData_ )
+    {
+      transformData = transformData_;
+      return *this;
+    }
+
+    GeometryTrianglesNV & setTransformOffset( DeviceSize transformOffset_ )
+    {
+      transformOffset = transformOffset_;
+      return *this;
+    }
+
+    operator VkGeometryTrianglesNV const&() const
+    {
+      return *reinterpret_cast<const VkGeometryTrianglesNV*>( this );
+    }
+
+    operator VkGeometryTrianglesNV &()
+    {
+      return *reinterpret_cast<VkGeometryTrianglesNV*>( this );
+    }
+
+    bool operator==( GeometryTrianglesNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( vertexData == rhs.vertexData )
+          && ( vertexOffset == rhs.vertexOffset )
+          && ( vertexCount == rhs.vertexCount )
+          && ( vertexStride == rhs.vertexStride )
+          && ( vertexFormat == rhs.vertexFormat )
+          && ( indexData == rhs.indexData )
+          && ( indexOffset == rhs.indexOffset )
+          && ( indexCount == rhs.indexCount )
+          && ( indexType == rhs.indexType )
+          && ( transformData == rhs.transformData )
+          && ( transformOffset == rhs.transformOffset );
+    }
+
+    bool operator!=( GeometryTrianglesNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eGeometryTrianglesNV;
+
+  public:
+    const void* pNext = nullptr;
+    Buffer vertexData;
+    DeviceSize vertexOffset;
+    uint32_t vertexCount;
+    DeviceSize vertexStride;
+    Format vertexFormat;
+    Buffer indexData;
+    DeviceSize indexOffset;
+    uint32_t indexCount;
+    IndexType indexType;
+    Buffer transformData;
+    DeviceSize transformOffset;
+  };
+  static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "struct and wrapper have different size!" );
+
+  struct GeometryAABBNV
+  {
+    GeometryAABBNV( Buffer aabbData_ = Buffer(),
+                    uint32_t numAABBs_ = 0,
+                    uint32_t stride_ = 0,
+                    DeviceSize offset_ = 0 )
+      : aabbData( aabbData_ )
+      , numAABBs( numAABBs_ )
+      , stride( stride_ )
+      , offset( offset_ )
+    {}
+
+    GeometryAABBNV( VkGeometryAABBNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryAABBNV ) );
+    }
+
+    GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryAABBNV ) );
+      return *this;
+    }
+
+    GeometryAABBNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    GeometryAABBNV & setAabbData( Buffer aabbData_ )
+    {
+      aabbData = aabbData_;
+      return *this;
+    }
+
+    GeometryAABBNV & setNumAABBs( uint32_t numAABBs_ )
+    {
+      numAABBs = numAABBs_;
+      return *this;
+    }
+
+    GeometryAABBNV & setStride( uint32_t stride_ )
+    {
+      stride = stride_;
+      return *this;
+    }
+
+    GeometryAABBNV & setOffset( DeviceSize offset_ )
+    {
+      offset = offset_;
+      return *this;
+    }
+
+    operator VkGeometryAABBNV const&() const
+    {
+      return *reinterpret_cast<const VkGeometryAABBNV*>( this );
+    }
+
+    operator VkGeometryAABBNV &()
+    {
+      return *reinterpret_cast<VkGeometryAABBNV*>( this );
+    }
+
+    bool operator==( GeometryAABBNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( aabbData == rhs.aabbData )
+          && ( numAABBs == rhs.numAABBs )
+          && ( stride == rhs.stride )
+          && ( offset == rhs.offset );
+    }
+
+    bool operator!=( GeometryAABBNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eGeometryAabbNV;
+
+  public:
+    const void* pNext = nullptr;
+    Buffer aabbData;
+    uint32_t numAABBs;
+    uint32_t stride;
+    DeviceSize offset;
+  };
+  static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" );
+
+  struct GeometryDataNV
+  {
+    GeometryDataNV( GeometryTrianglesNV triangles_ = GeometryTrianglesNV(),
+                    GeometryAABBNV aabbs_ = GeometryAABBNV() )
+      : triangles( triangles_ )
+      , aabbs( aabbs_ )
+    {}
+
+    GeometryDataNV( VkGeometryDataNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryDataNV ) );
+    }
+
+    GeometryDataNV& operator=( VkGeometryDataNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryDataNV ) );
+      return *this;
+    }
+
+    GeometryDataNV & setTriangles( GeometryTrianglesNV triangles_ )
+    {
+      triangles = triangles_;
+      return *this;
+    }
+
+    GeometryDataNV & setAabbs( GeometryAABBNV aabbs_ )
+    {
+      aabbs = aabbs_;
+      return *this;
+    }
+
+    operator VkGeometryDataNV const&() const
+    {
+      return *reinterpret_cast<const VkGeometryDataNV*>( this );
+    }
+
+    operator VkGeometryDataNV &()
+    {
+      return *reinterpret_cast<VkGeometryDataNV*>( this );
+    }
+
+    bool operator==( GeometryDataNV const& rhs ) const
+    {
+      return ( triangles == rhs.triangles )
+          && ( aabbs == rhs.aabbs );
+    }
+
+    bool operator!=( GeometryDataNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    GeometryTrianglesNV triangles;
+    GeometryAABBNV aabbs;
+  };
+  static_assert( sizeof( GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" );
+
+  struct GeometryNV
+  {
+    GeometryNV( GeometryTypeNV geometryType_ = GeometryTypeNV::eTriangles,
+                GeometryDataNV geometry_ = GeometryDataNV(),
+                GeometryFlagsNV flags_ = GeometryFlagsNV() )
+      : geometryType( geometryType_ )
+      , geometry( geometry_ )
+      , flags( flags_ )
+    {}
+
+    GeometryNV( VkGeometryNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryNV ) );
+    }
+
+    GeometryNV& operator=( VkGeometryNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( GeometryNV ) );
+      return *this;
+    }
+
+    GeometryNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    GeometryNV & setGeometryType( GeometryTypeNV geometryType_ )
+    {
+      geometryType = geometryType_;
+      return *this;
+    }
+
+    GeometryNV & setGeometry( GeometryDataNV geometry_ )
+    {
+      geometry = geometry_;
+      return *this;
+    }
+
+    GeometryNV & setFlags( GeometryFlagsNV flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    operator VkGeometryNV const&() const
+    {
+      return *reinterpret_cast<const VkGeometryNV*>( this );
+    }
+
+    operator VkGeometryNV &()
+    {
+      return *reinterpret_cast<VkGeometryNV*>( this );
+    }
+
+    bool operator==( GeometryNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( geometryType == rhs.geometryType )
+          && ( geometry == rhs.geometry )
+          && ( flags == rhs.flags );
+    }
+
+    bool operator!=( GeometryNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eGeometryNV;
+
+  public:
+    const void* pNext = nullptr;
+    GeometryTypeNV geometryType;
+    GeometryDataNV geometry;
+    GeometryFlagsNV flags;
+  };
+  static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" );
+
+  struct AccelerationStructureInfoNV
+  {
+    AccelerationStructureInfoNV( AccelerationStructureTypeNV type_ = AccelerationStructureTypeNV::eTopLevel,
+                                 BuildAccelerationStructureFlagsNV flags_ = BuildAccelerationStructureFlagsNV(),
+                                 uint32_t instanceCount_ = 0,
+                                 uint32_t geometryCount_ = 0,
+                                 const GeometryNV* pGeometries_ = nullptr )
+      : type( type_ )
+      , flags( flags_ )
+      , instanceCount( instanceCount_ )
+      , geometryCount( geometryCount_ )
+      , pGeometries( pGeometries_ )
+    {}
+
+    AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) );
+    }
+
+    AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) );
+      return *this;
+    }
+
+    AccelerationStructureInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    AccelerationStructureInfoNV & setType( AccelerationStructureTypeNV type_ )
+    {
+      type = type_;
+      return *this;
+    }
+
+    AccelerationStructureInfoNV & setFlags( BuildAccelerationStructureFlagsNV flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    AccelerationStructureInfoNV & setInstanceCount( uint32_t instanceCount_ )
+    {
+      instanceCount = instanceCount_;
+      return *this;
+    }
+
+    AccelerationStructureInfoNV & setGeometryCount( uint32_t geometryCount_ )
+    {
+      geometryCount = geometryCount_;
+      return *this;
+    }
+
+    AccelerationStructureInfoNV & setPGeometries( const GeometryNV* pGeometries_ )
+    {
+      pGeometries = pGeometries_;
+      return *this;
+    }
+
+    operator VkAccelerationStructureInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkAccelerationStructureInfoNV*>( this );
+    }
+
+    operator VkAccelerationStructureInfoNV &()
+    {
+      return *reinterpret_cast<VkAccelerationStructureInfoNV*>( this );
+    }
+
+    bool operator==( AccelerationStructureInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( type == rhs.type )
+          && ( flags == rhs.flags )
+          && ( instanceCount == rhs.instanceCount )
+          && ( geometryCount == rhs.geometryCount )
+          && ( pGeometries == rhs.pGeometries );
+    }
+
+    bool operator!=( AccelerationStructureInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eAccelerationStructureInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    AccelerationStructureTypeNV type;
+    BuildAccelerationStructureFlagsNV flags;
+    uint32_t instanceCount;
+    uint32_t geometryCount;
+    const GeometryNV* pGeometries;
+  };
+  static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "struct and wrapper have different size!" );
+
+  struct AccelerationStructureCreateInfoNV
+  {
+    AccelerationStructureCreateInfoNV( DeviceSize compactedSize_ = 0,
+                                       AccelerationStructureInfoNV info_ = AccelerationStructureInfoNV() )
+      : compactedSize( compactedSize_ )
+      , info( info_ )
+    {}
+
+    AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) );
+    }
+
+    AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) );
+      return *this;
+    }
+
+    AccelerationStructureCreateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    AccelerationStructureCreateInfoNV & setCompactedSize( DeviceSize compactedSize_ )
+    {
+      compactedSize = compactedSize_;
+      return *this;
+    }
+
+    AccelerationStructureCreateInfoNV & setInfo( AccelerationStructureInfoNV info_ )
+    {
+      info = info_;
+      return *this;
+    }
+
+    operator VkAccelerationStructureCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( this );
+    }
+
+    operator VkAccelerationStructureCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>( this );
+    }
+
+    bool operator==( AccelerationStructureCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( compactedSize == rhs.compactedSize )
+          && ( info == rhs.info );
+    }
+
+    bool operator!=( AccelerationStructureCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eAccelerationStructureCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    DeviceSize compactedSize;
+    AccelerationStructureInfoNV info;
+  };
+  static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "struct and wrapper have different size!" );
+
+  struct AccelerationStructureMemoryRequirementsInfoNV
+  {
+    AccelerationStructureMemoryRequirementsInfoNV( AccelerationStructureMemoryRequirementsTypeNV type_ = AccelerationStructureMemoryRequirementsTypeNV::eObject,
+                                                   AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV() )
+      : type( type_ )
+      , accelerationStructure( accelerationStructure_ )
+    {}
+
+    AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) );
+    }
+
+    AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) );
+      return *this;
+    }
+
+    AccelerationStructureMemoryRequirementsInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    AccelerationStructureMemoryRequirementsInfoNV & setType( AccelerationStructureMemoryRequirementsTypeNV type_ )
+    {
+      type = type_;
+      return *this;
+    }
+
+    AccelerationStructureMemoryRequirementsInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ )
+    {
+      accelerationStructure = accelerationStructure_;
+      return *this;
+    }
+
+    operator VkAccelerationStructureMemoryRequirementsInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( this );
+    }
+
+    operator VkAccelerationStructureMemoryRequirementsInfoNV &()
+    {
+      return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>( this );
+    }
+
+    bool operator==( AccelerationStructureMemoryRequirementsInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( type == rhs.type )
+          && ( accelerationStructure == rhs.accelerationStructure );
+    }
+
+    bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    AccelerationStructureMemoryRequirementsTypeNV type;
+    AccelerationStructureNV accelerationStructure;
+  };
+  static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "struct and wrapper have different size!" );
+
+  struct AcquireNextImageInfoKHR
+  {
+    AcquireNextImageInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR(),
+                             uint64_t timeout_ = 0,
+                             Semaphore semaphore_ = Semaphore(),
+                             Fence fence_ = Fence(),
+                             uint32_t deviceMask_ = 0 )
+      : swapchain( swapchain_ )
+      , timeout( timeout_ )
+      , semaphore( semaphore_ )
+      , fence( fence_ )
+      , deviceMask( deviceMask_ )
+    {}
+
+    AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHR ) );
+    }
+
+    AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHR ) );
+      return *this;
+    }
+
+    AcquireNextImageInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    AcquireNextImageInfoKHR & setSwapchain( SwapchainKHR swapchain_ )
+    {
+      swapchain = swapchain_;
+      return *this;
+    }
+
+    AcquireNextImageInfoKHR & setTimeout( uint64_t timeout_ )
+    {
+      timeout = timeout_;
+      return *this;
+    }
+
+    AcquireNextImageInfoKHR & setSemaphore( Semaphore semaphore_ )
+    {
+      semaphore = semaphore_;
+      return *this;
+    }
+
+    AcquireNextImageInfoKHR & setFence( Fence fence_ )
+    {
+      fence = fence_;
+      return *this;
+    }
+
+    AcquireNextImageInfoKHR & setDeviceMask( uint32_t deviceMask_ )
+    {
+      deviceMask = deviceMask_;
+      return *this;
+    }
+
+    operator VkAcquireNextImageInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkAcquireNextImageInfoKHR*>( this );
+    }
+
+    operator VkAcquireNextImageInfoKHR &()
+    {
+      return *reinterpret_cast<VkAcquireNextImageInfoKHR*>( this );
+    }
+
+    bool operator==( AcquireNextImageInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( swapchain == rhs.swapchain )
+          && ( timeout == rhs.timeout )
+          && ( semaphore == rhs.semaphore )
+          && ( fence == rhs.fence )
+          && ( deviceMask == rhs.deviceMask );
+    }
+
+    bool operator!=( AcquireNextImageInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eAcquireNextImageInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    SwapchainKHR swapchain;
+    uint64_t timeout;
+    Semaphore semaphore;
+    Fence fence;
+    uint32_t deviceMask;
+  };
+  static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "struct and wrapper have different size!" );
+
+  struct AllocationCallbacks
+  {
+    AllocationCallbacks( void* pUserData_ = nullptr,
+                         PFN_vkAllocationFunction pfnAllocation_ = nullptr,
+                         PFN_vkReallocationFunction pfnReallocation_ = nullptr,
+                         PFN_vkFreeFunction pfnFree_ = nullptr,
+                         PFN_vkInternalAllocationNotification pfnInternalAllocation_ = nullptr,
+                         PFN_vkInternalFreeNotification pfnInternalFree_ = nullptr )
+      : pUserData( pUserData_ )
+      , pfnAllocation( pfnAllocation_ )
+      , pfnReallocation( pfnReallocation_ )
+      , pfnFree( pfnFree_ )
+      , pfnInternalAllocation( pfnInternalAllocation_ )
+      , pfnInternalFree( pfnInternalFree_ )
+    {}
+
+    AllocationCallbacks( VkAllocationCallbacks const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
+    }
+
+    AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
+      return *this;
+    }
+
+    AllocationCallbacks & setPUserData( void* pUserData_ )
+    {
+      pUserData = pUserData_;
+      return *this;
+    }
+
+    AllocationCallbacks & setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ )
+    {
+      pfnAllocation = pfnAllocation_;
+      return *this;
+    }
+
+    AllocationCallbacks & setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ )
+    {
+      pfnReallocation = pfnReallocation_;
+      return *this;
+    }
+
+    AllocationCallbacks & setPfnFree( PFN_vkFreeFunction pfnFree_ )
+    {
+      pfnFree = pfnFree_;
+      return *this;
+    }
+
+    AllocationCallbacks & setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ )
+    {
+      pfnInternalAllocation = pfnInternalAllocation_;
+      return *this;
+    }
+
+    AllocationCallbacks & setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ )
+    {
+      pfnInternalFree = pfnInternalFree_;
+      return *this;
+    }
+
+    operator VkAllocationCallbacks const&() const
+    {
+      return *reinterpret_cast<const VkAllocationCallbacks*>( this );
+    }
+
+    operator VkAllocationCallbacks &()
+    {
+      return *reinterpret_cast<VkAllocationCallbacks*>( this );
+    }
+
+    bool operator==( AllocationCallbacks const& rhs ) const
+    {
+      return ( pUserData == rhs.pUserData )
+          && ( pfnAllocation == rhs.pfnAllocation )
+          && ( pfnReallocation == rhs.pfnReallocation )
+          && ( pfnFree == rhs.pfnFree )
+          && ( pfnInternalAllocation == rhs.pfnInternalAllocation )
+          && ( pfnInternalFree == rhs.pfnInternalFree );
+    }
+
+    bool operator!=( AllocationCallbacks const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    void* pUserData;
+    PFN_vkAllocationFunction pfnAllocation;
+    PFN_vkReallocationFunction pfnReallocation;
+    PFN_vkFreeFunction pfnFree;
+    PFN_vkInternalAllocationNotification pfnInternalAllocation;
+    PFN_vkInternalFreeNotification pfnInternalFree;
+  };
+  static_assert( sizeof( AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" );
+
+  struct ComponentMapping
+  {
+    ComponentMapping( ComponentSwizzle r_ = ComponentSwizzle::eIdentity,
+                      ComponentSwizzle g_ = ComponentSwizzle::eIdentity,
+                      ComponentSwizzle b_ = ComponentSwizzle::eIdentity,
+                      ComponentSwizzle a_ = ComponentSwizzle::eIdentity )
+      : r( r_ )
+      , g( g_ )
+      , b( b_ )
+      , a( a_ )
+    {}
+
+    ComponentMapping( VkComponentMapping const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ComponentMapping ) );
+    }
+
+    ComponentMapping& operator=( VkComponentMapping const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ComponentMapping ) );
+      return *this;
+    }
+
+    ComponentMapping & setR( ComponentSwizzle r_ )
+    {
+      r = r_;
+      return *this;
+    }
+
+    ComponentMapping & setG( ComponentSwizzle g_ )
+    {
+      g = g_;
+      return *this;
+    }
+
+    ComponentMapping & setB( ComponentSwizzle b_ )
+    {
+      b = b_;
+      return *this;
+    }
+
+    ComponentMapping & setA( ComponentSwizzle a_ )
+    {
+      a = a_;
+      return *this;
+    }
+
+    operator VkComponentMapping const&() const
+    {
+      return *reinterpret_cast<const VkComponentMapping*>( this );
+    }
+
+    operator VkComponentMapping &()
+    {
+      return *reinterpret_cast<VkComponentMapping*>( this );
+    }
+
+    bool operator==( ComponentMapping const& rhs ) const
+    {
+      return ( r == rhs.r )
+          && ( g == rhs.g )
+          && ( b == rhs.b )
+          && ( a == rhs.a );
+    }
+
+    bool operator!=( ComponentMapping const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ComponentSwizzle r;
+    ComponentSwizzle g;
+    ComponentSwizzle b;
+    ComponentSwizzle a;
+  };
+  static_assert( sizeof( ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  struct AndroidHardwareBufferFormatPropertiesANDROID
+  {
+    operator VkAndroidHardwareBufferFormatPropertiesANDROID const&() const
+    {
+      return *reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>( this );
+    }
+
+    operator VkAndroidHardwareBufferFormatPropertiesANDROID &()
+    {
+      return *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>( this );
+    }
+
+    bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( format == rhs.format )
+          && ( externalFormat == rhs.externalFormat )
+          && ( formatFeatures == rhs.formatFeatures )
+          && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents )
+          && ( suggestedYcbcrModel == rhs.suggestedYcbcrModel )
+          && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange )
+          && ( suggestedXChromaOffset == rhs.suggestedXChromaOffset )
+          && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
+    }
+
+    bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID;
+
+  public:
+    void* pNext = nullptr;
+    Format format;
+    uint64_t externalFormat;
+    FormatFeatureFlags formatFeatures;
+    ComponentMapping samplerYcbcrConversionComponents;
+    SamplerYcbcrModelConversion suggestedYcbcrModel;
+    SamplerYcbcrRange suggestedYcbcrRange;
+    ChromaLocation suggestedXChromaOffset;
+    ChromaLocation suggestedYChromaOffset;
+  };
+  static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  struct AndroidHardwareBufferPropertiesANDROID
+  {
+    operator VkAndroidHardwareBufferPropertiesANDROID const&() const
+    {
+      return *reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID*>( this );
+    }
+
+    operator VkAndroidHardwareBufferPropertiesANDROID &()
+    {
+      return *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( this );
+    }
+
+    bool operator==( AndroidHardwareBufferPropertiesANDROID const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( allocationSize == rhs.allocationSize )
+          && ( memoryTypeBits == rhs.memoryTypeBits );
+    }
+
+    bool operator!=( AndroidHardwareBufferPropertiesANDROID const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID;
+
+  public:
+    void* pNext = nullptr;
+    DeviceSize allocationSize;
+    uint32_t memoryTypeBits;
+  };
+  static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  struct AndroidHardwareBufferUsageANDROID
+  {
+    operator VkAndroidHardwareBufferUsageANDROID const&() const
+    {
+      return *reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>( this );
+    }
+
+    operator VkAndroidHardwareBufferUsageANDROID &()
+    {
+      return *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>( this );
+    }
+
+    bool operator==( AndroidHardwareBufferUsageANDROID const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage );
+    }
+
+    bool operator!=( AndroidHardwareBufferUsageANDROID const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID;
+
+  public:
+    void* pNext = nullptr;
+    uint64_t androidHardwareBufferUsage;
+  };
+  static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  struct AndroidSurfaceCreateInfoKHR
+  {
+    AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = AndroidSurfaceCreateFlagsKHR(),
+                                 struct ANativeWindow* window_ = nullptr )
+      : flags( flags_ )
+      , window( window_ )
+    {}
+
+    AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) );
+    }
+
+    AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) );
+      return *this;
+    }
+
+    AndroidSurfaceCreateInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    AndroidSurfaceCreateInfoKHR & setFlags( AndroidSurfaceCreateFlagsKHR flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    AndroidSurfaceCreateInfoKHR & setWindow( struct ANativeWindow* window_ )
+    {
+      window = window_;
+      return *this;
+    }
+
+    operator VkAndroidSurfaceCreateInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( this );
+    }
+
+    operator VkAndroidSurfaceCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>( this );
+    }
+
+    bool operator==( AndroidSurfaceCreateInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( window == rhs.window );
+    }
+
+    bool operator!=( AndroidSurfaceCreateInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    AndroidSurfaceCreateFlagsKHR flags;
+    struct ANativeWindow* window;
+  };
+  static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
   struct ApplicationInfo
   {
     ApplicationInfo( const char* pApplicationName_ = nullptr,
@@ -9511,8 +16737,7 @@ public:
       , pEngineName( pEngineName_ )
       , engineVersion( engineVersion_ )
       , apiVersion( apiVersion_ )
-    {
-    }
+    {}
 
     ApplicationInfo( VkApplicationInfo const & rhs )
     {
@@ -9524,37 +16749,38 @@ public:
       memcpy( this, &rhs, sizeof( ApplicationInfo ) );
       return *this;
     }
-    ApplicationInfo& setPNext( const void* pNext_ )
+
+    ApplicationInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    ApplicationInfo& setPApplicationName( const char* pApplicationName_ )
+    ApplicationInfo & setPApplicationName( const char* pApplicationName_ )
     {
       pApplicationName = pApplicationName_;
       return *this;
     }
 
-    ApplicationInfo& setApplicationVersion( uint32_t applicationVersion_ )
+    ApplicationInfo & setApplicationVersion( uint32_t applicationVersion_ )
     {
       applicationVersion = applicationVersion_;
       return *this;
     }
 
-    ApplicationInfo& setPEngineName( const char* pEngineName_ )
+    ApplicationInfo & setPEngineName( const char* pEngineName_ )
     {
       pEngineName = pEngineName_;
       return *this;
     }
 
-    ApplicationInfo& setEngineVersion( uint32_t engineVersion_ )
+    ApplicationInfo & setEngineVersion( uint32_t engineVersion_ )
     {
       engineVersion = engineVersion_;
       return *this;
     }
 
-    ApplicationInfo& setApiVersion( uint32_t apiVersion_ )
+    ApplicationInfo & setApiVersion( uint32_t apiVersion_ )
     {
       apiVersion = apiVersion_;
       return *this;
@@ -9562,12 +16788,12 @@ public:
 
     operator VkApplicationInfo const&() const
     {
-      return *reinterpret_cast<const VkApplicationInfo*>(this);
+      return *reinterpret_cast<const VkApplicationInfo*>( this );
     }
 
     operator VkApplicationInfo &()
     {
-      return *reinterpret_cast<VkApplicationInfo*>(this);
+      return *reinterpret_cast<VkApplicationInfo*>( this );
     }
 
     bool operator==( ApplicationInfo const& rhs ) const
@@ -9599,395 +16825,4510 @@ public:
   };
   static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" );
 
-  struct InstanceCreateInfo
+  struct AttachmentDescription
   {
-    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 )
+    AttachmentDescription( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(),
+                           Format format_ = Format::eUndefined,
+                           SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
+                           AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad,
+                           AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore,
+                           AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad,
+                           AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore,
+                           ImageLayout initialLayout_ = ImageLayout::eUndefined,
+                           ImageLayout finalLayout_ = ImageLayout::eUndefined )
       : flags( flags_ )
-      , pApplicationInfo( pApplicationInfo_ )
-      , enabledLayerCount( enabledLayerCount_ )
-      , ppEnabledLayerNames( ppEnabledLayerNames_ )
-      , enabledExtensionCount( enabledExtensionCount_ )
-      , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
+      , format( format_ )
+      , samples( samples_ )
+      , loadOp( loadOp_ )
+      , storeOp( storeOp_ )
+      , stencilLoadOp( stencilLoadOp_ )
+      , stencilStoreOp( stencilStoreOp_ )
+      , initialLayout( initialLayout_ )
+      , finalLayout( finalLayout_ )
+    {}
+
+    AttachmentDescription( VkAttachmentDescription const & rhs )
     {
+      memcpy( this, &rhs, sizeof( AttachmentDescription ) );
     }
 
-    InstanceCreateInfo( VkInstanceCreateInfo const & rhs )
+    AttachmentDescription& operator=( VkAttachmentDescription const & rhs )
     {
-      memcpy( this, &rhs, sizeof( InstanceCreateInfo ) );
-    }
-
-    InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( InstanceCreateInfo ) );
-      return *this;
-    }
-    InstanceCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
+      memcpy( this, &rhs, sizeof( AttachmentDescription ) );
       return *this;
     }
 
-    InstanceCreateInfo& setFlags( InstanceCreateFlags flags_ )
+    AttachmentDescription & setFlags( AttachmentDescriptionFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    InstanceCreateInfo& setPApplicationInfo( const ApplicationInfo* pApplicationInfo_ )
+    AttachmentDescription & setFormat( Format format_ )
     {
-      pApplicationInfo = pApplicationInfo_;
+      format = format_;
       return *this;
     }
 
-    InstanceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ )
+    AttachmentDescription & setSamples( SampleCountFlagBits samples_ )
     {
-      enabledLayerCount = enabledLayerCount_;
+      samples = samples_;
       return *this;
     }
 
-    InstanceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ )
+    AttachmentDescription & setLoadOp( AttachmentLoadOp loadOp_ )
     {
-      ppEnabledLayerNames = ppEnabledLayerNames_;
+      loadOp = loadOp_;
       return *this;
     }
 
-    InstanceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ )
+    AttachmentDescription & setStoreOp( AttachmentStoreOp storeOp_ )
     {
-      enabledExtensionCount = enabledExtensionCount_;
+      storeOp = storeOp_;
       return *this;
     }
 
-    InstanceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ )
+    AttachmentDescription & setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
     {
-      ppEnabledExtensionNames = ppEnabledExtensionNames_;
+      stencilLoadOp = stencilLoadOp_;
       return *this;
     }
 
-    operator VkInstanceCreateInfo const&() const
+    AttachmentDescription & setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
     {
-      return *reinterpret_cast<const VkInstanceCreateInfo*>(this);
+      stencilStoreOp = stencilStoreOp_;
+      return *this;
     }
 
-    operator VkInstanceCreateInfo &()
+    AttachmentDescription & setInitialLayout( ImageLayout initialLayout_ )
     {
-      return *reinterpret_cast<VkInstanceCreateInfo*>(this);
+      initialLayout = initialLayout_;
+      return *this;
     }
 
-    bool operator==( InstanceCreateInfo const& rhs ) const
+    AttachmentDescription & setFinalLayout( ImageLayout finalLayout_ )
+    {
+      finalLayout = finalLayout_;
+      return *this;
+    }
+
+    operator VkAttachmentDescription const&() const
+    {
+      return *reinterpret_cast<const VkAttachmentDescription*>( this );
+    }
+
+    operator VkAttachmentDescription &()
+    {
+      return *reinterpret_cast<VkAttachmentDescription*>( this );
+    }
+
+    bool operator==( AttachmentDescription const& rhs ) const
+    {
+      return ( flags == rhs.flags )
+          && ( format == rhs.format )
+          && ( samples == rhs.samples )
+          && ( loadOp == rhs.loadOp )
+          && ( storeOp == rhs.storeOp )
+          && ( stencilLoadOp == rhs.stencilLoadOp )
+          && ( stencilStoreOp == rhs.stencilStoreOp )
+          && ( initialLayout == rhs.initialLayout )
+          && ( finalLayout == rhs.finalLayout );
+    }
+
+    bool operator!=( AttachmentDescription const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    AttachmentDescriptionFlags flags;
+    Format format;
+    SampleCountFlagBits samples;
+    AttachmentLoadOp loadOp;
+    AttachmentStoreOp storeOp;
+    AttachmentLoadOp stencilLoadOp;
+    AttachmentStoreOp stencilStoreOp;
+    ImageLayout initialLayout;
+    ImageLayout finalLayout;
+  };
+  static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" );
+
+  struct AttachmentDescription2KHR
+  {
+    AttachmentDescription2KHR( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(),
+                               Format format_ = Format::eUndefined,
+                               SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
+                               AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad,
+                               AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore,
+                               AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad,
+                               AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore,
+                               ImageLayout initialLayout_ = ImageLayout::eUndefined,
+                               ImageLayout finalLayout_ = ImageLayout::eUndefined )
+      : flags( flags_ )
+      , format( format_ )
+      , samples( samples_ )
+      , loadOp( loadOp_ )
+      , storeOp( storeOp_ )
+      , stencilLoadOp( stencilLoadOp_ )
+      , stencilStoreOp( stencilStoreOp_ )
+      , initialLayout( initialLayout_ )
+      , finalLayout( finalLayout_ )
+    {}
+
+    AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) );
+    }
+
+    AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) );
+      return *this;
+    }
+
+    AttachmentDescription2KHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    AttachmentDescription2KHR & setFlags( AttachmentDescriptionFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    AttachmentDescription2KHR & setFormat( Format format_ )
+    {
+      format = format_;
+      return *this;
+    }
+
+    AttachmentDescription2KHR & setSamples( SampleCountFlagBits samples_ )
+    {
+      samples = samples_;
+      return *this;
+    }
+
+    AttachmentDescription2KHR & setLoadOp( AttachmentLoadOp loadOp_ )
+    {
+      loadOp = loadOp_;
+      return *this;
+    }
+
+    AttachmentDescription2KHR & setStoreOp( AttachmentStoreOp storeOp_ )
+    {
+      storeOp = storeOp_;
+      return *this;
+    }
+
+    AttachmentDescription2KHR & setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
+    {
+      stencilLoadOp = stencilLoadOp_;
+      return *this;
+    }
+
+    AttachmentDescription2KHR & setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
+    {
+      stencilStoreOp = stencilStoreOp_;
+      return *this;
+    }
+
+    AttachmentDescription2KHR & setInitialLayout( ImageLayout initialLayout_ )
+    {
+      initialLayout = initialLayout_;
+      return *this;
+    }
+
+    AttachmentDescription2KHR & setFinalLayout( ImageLayout finalLayout_ )
+    {
+      finalLayout = finalLayout_;
+      return *this;
+    }
+
+    operator VkAttachmentDescription2KHR const&() const
+    {
+      return *reinterpret_cast<const VkAttachmentDescription2KHR*>( this );
+    }
+
+    operator VkAttachmentDescription2KHR &()
+    {
+      return *reinterpret_cast<VkAttachmentDescription2KHR*>( this );
+    }
+
+    bool operator==( AttachmentDescription2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
           && ( flags == rhs.flags )
-          && ( pApplicationInfo == rhs.pApplicationInfo )
-          && ( enabledLayerCount == rhs.enabledLayerCount )
-          && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames )
-          && ( enabledExtensionCount == rhs.enabledExtensionCount )
-          && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames );
+          && ( format == rhs.format )
+          && ( samples == rhs.samples )
+          && ( loadOp == rhs.loadOp )
+          && ( storeOp == rhs.storeOp )
+          && ( stencilLoadOp == rhs.stencilLoadOp )
+          && ( stencilStoreOp == rhs.stencilStoreOp )
+          && ( initialLayout == rhs.initialLayout )
+          && ( finalLayout == rhs.finalLayout );
     }
 
-    bool operator!=( InstanceCreateInfo const& rhs ) const
+    bool operator!=( AttachmentDescription2KHR const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eInstanceCreateInfo;
+    StructureType sType = StructureType::eAttachmentDescription2KHR;
 
   public:
     const void* pNext = nullptr;
-    InstanceCreateFlags flags;
-    const ApplicationInfo* pApplicationInfo;
-    uint32_t enabledLayerCount;
-    const char* const* ppEnabledLayerNames;
-    uint32_t enabledExtensionCount;
-    const char* const* ppEnabledExtensionNames;
+    AttachmentDescriptionFlags flags;
+    Format format;
+    SampleCountFlagBits samples;
+    AttachmentLoadOp loadOp;
+    AttachmentStoreOp storeOp;
+    AttachmentLoadOp stencilLoadOp;
+    AttachmentStoreOp stencilStoreOp;
+    ImageLayout initialLayout;
+    ImageLayout finalLayout;
   };
-  static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" );
+  static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "struct and wrapper have different size!" );
 
-  struct MemoryAllocateInfo
+  struct AttachmentReference
   {
-    MemoryAllocateInfo( DeviceSize allocationSize_ = 0,
-                        uint32_t memoryTypeIndex_ = 0 )
-      : allocationSize( allocationSize_ )
-      , memoryTypeIndex( memoryTypeIndex_ )
+    AttachmentReference( uint32_t attachment_ = 0,
+                         ImageLayout layout_ = ImageLayout::eUndefined )
+      : attachment( attachment_ )
+      , layout( layout_ )
+    {}
+
+    AttachmentReference( VkAttachmentReference const & rhs )
     {
+      memcpy( this, &rhs, sizeof( AttachmentReference ) );
     }
 
-    MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs )
+    AttachmentReference& operator=( VkAttachmentReference const & rhs )
     {
-      memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) );
-    }
-
-    MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) );
+      memcpy( this, &rhs, sizeof( AttachmentReference ) );
       return *this;
     }
-    MemoryAllocateInfo& setPNext( const void* pNext_ )
+
+    AttachmentReference & setAttachment( uint32_t attachment_ )
+    {
+      attachment = attachment_;
+      return *this;
+    }
+
+    AttachmentReference & setLayout( ImageLayout layout_ )
+    {
+      layout = layout_;
+      return *this;
+    }
+
+    operator VkAttachmentReference const&() const
+    {
+      return *reinterpret_cast<const VkAttachmentReference*>( this );
+    }
+
+    operator VkAttachmentReference &()
+    {
+      return *reinterpret_cast<VkAttachmentReference*>( this );
+    }
+
+    bool operator==( AttachmentReference const& rhs ) const
+    {
+      return ( attachment == rhs.attachment )
+          && ( layout == rhs.layout );
+    }
+
+    bool operator!=( AttachmentReference const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t attachment;
+    ImageLayout layout;
+  };
+  static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" );
+
+  struct AttachmentReference2KHR
+  {
+    AttachmentReference2KHR( uint32_t attachment_ = 0,
+                             ImageLayout layout_ = ImageLayout::eUndefined,
+                             ImageAspectFlags aspectMask_ = ImageAspectFlags() )
+      : attachment( attachment_ )
+      , layout( layout_ )
+      , aspectMask( aspectMask_ )
+    {}
+
+    AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) );
+    }
+
+    AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) );
+      return *this;
+    }
+
+    AttachmentReference2KHR & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    MemoryAllocateInfo& setAllocationSize( DeviceSize allocationSize_ )
+    AttachmentReference2KHR & setAttachment( uint32_t attachment_ )
     {
-      allocationSize = allocationSize_;
+      attachment = attachment_;
       return *this;
     }
 
-    MemoryAllocateInfo& setMemoryTypeIndex( uint32_t memoryTypeIndex_ )
+    AttachmentReference2KHR & setLayout( ImageLayout layout_ )
     {
-      memoryTypeIndex = memoryTypeIndex_;
+      layout = layout_;
       return *this;
     }
 
-    operator VkMemoryAllocateInfo const&() const
+    AttachmentReference2KHR & setAspectMask( ImageAspectFlags aspectMask_ )
     {
-      return *reinterpret_cast<const VkMemoryAllocateInfo*>(this);
+      aspectMask = aspectMask_;
+      return *this;
     }
 
-    operator VkMemoryAllocateInfo &()
+    operator VkAttachmentReference2KHR const&() const
     {
-      return *reinterpret_cast<VkMemoryAllocateInfo*>(this);
+      return *reinterpret_cast<const VkAttachmentReference2KHR*>( this );
     }
 
-    bool operator==( MemoryAllocateInfo const& rhs ) const
+    operator VkAttachmentReference2KHR &()
+    {
+      return *reinterpret_cast<VkAttachmentReference2KHR*>( this );
+    }
+
+    bool operator==( AttachmentReference2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( allocationSize == rhs.allocationSize )
-          && ( memoryTypeIndex == rhs.memoryTypeIndex );
+          && ( attachment == rhs.attachment )
+          && ( layout == rhs.layout )
+          && ( aspectMask == rhs.aspectMask );
     }
 
-    bool operator!=( MemoryAllocateInfo const& rhs ) const
+    bool operator!=( AttachmentReference2KHR const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eMemoryAllocateInfo;
+    StructureType sType = StructureType::eAttachmentReference2KHR;
 
   public:
     const void* pNext = nullptr;
-    DeviceSize allocationSize;
-    uint32_t memoryTypeIndex;
+    uint32_t attachment;
+    ImageLayout layout;
+    ImageAspectFlags aspectMask;
   };
-  static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" );
+  static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "struct and wrapper have different size!" );
 
-  struct MappedMemoryRange
+  struct Extent2D
   {
-    MappedMemoryRange( DeviceMemory memory_ = DeviceMemory(),
-                       DeviceSize offset_ = 0,
-                       DeviceSize size_ = 0 )
-      : memory( memory_ )
-      , offset( offset_ )
-      , size( size_ )
+    Extent2D( uint32_t width_ = 0,
+              uint32_t height_ = 0 )
+      : width( width_ )
+      , height( height_ )
+    {}
+
+    Extent2D( VkExtent2D const & rhs )
     {
+      memcpy( this, &rhs, sizeof( Extent2D ) );
     }
 
-    MappedMemoryRange( VkMappedMemoryRange const & rhs )
+    Extent2D& operator=( VkExtent2D const & rhs )
     {
-      memcpy( this, &rhs, sizeof( MappedMemoryRange ) );
-    }
-
-    MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MappedMemoryRange ) );
+      memcpy( this, &rhs, sizeof( Extent2D ) );
       return *this;
     }
-    MappedMemoryRange& setPNext( const void* pNext_ )
+
+    Extent2D & setWidth( uint32_t width_ )
+    {
+      width = width_;
+      return *this;
+    }
+
+    Extent2D & setHeight( uint32_t height_ )
+    {
+      height = height_;
+      return *this;
+    }
+
+    operator VkExtent2D const&() const
+    {
+      return *reinterpret_cast<const VkExtent2D*>( this );
+    }
+
+    operator VkExtent2D &()
+    {
+      return *reinterpret_cast<VkExtent2D*>( this );
+    }
+
+    bool operator==( Extent2D const& rhs ) const
+    {
+      return ( width == rhs.width )
+          && ( height == rhs.height );
+    }
+
+    bool operator!=( Extent2D const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t width;
+    uint32_t height;
+  };
+  static_assert( sizeof( Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" );
+
+  struct SampleLocationEXT
+  {
+    SampleLocationEXT( float x_ = 0,
+                       float y_ = 0 )
+      : x( x_ )
+      , y( y_ )
+    {}
+
+    SampleLocationEXT( VkSampleLocationEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SampleLocationEXT ) );
+    }
+
+    SampleLocationEXT& operator=( VkSampleLocationEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SampleLocationEXT ) );
+      return *this;
+    }
+
+    SampleLocationEXT & setX( float x_ )
+    {
+      x = x_;
+      return *this;
+    }
+
+    SampleLocationEXT & setY( float y_ )
+    {
+      y = y_;
+      return *this;
+    }
+
+    operator VkSampleLocationEXT const&() const
+    {
+      return *reinterpret_cast<const VkSampleLocationEXT*>( this );
+    }
+
+    operator VkSampleLocationEXT &()
+    {
+      return *reinterpret_cast<VkSampleLocationEXT*>( this );
+    }
+
+    bool operator==( SampleLocationEXT const& rhs ) const
+    {
+      return ( x == rhs.x )
+          && ( y == rhs.y );
+    }
+
+    bool operator!=( SampleLocationEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    float x;
+    float y;
+  };
+  static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" );
+
+  struct SampleLocationsInfoEXT
+  {
+    SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1,
+                            Extent2D sampleLocationGridSize_ = Extent2D(),
+                            uint32_t sampleLocationsCount_ = 0,
+                            const SampleLocationEXT* pSampleLocations_ = nullptr )
+      : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
+      , sampleLocationGridSize( sampleLocationGridSize_ )
+      , sampleLocationsCount( sampleLocationsCount_ )
+      , pSampleLocations( pSampleLocations_ )
+    {}
+
+    SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
+    }
+
+    SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
+      return *this;
+    }
+
+    SampleLocationsInfoEXT & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    MappedMemoryRange& setMemory( DeviceMemory memory_ )
+    SampleLocationsInfoEXT & setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ )
+    {
+      sampleLocationsPerPixel = sampleLocationsPerPixel_;
+      return *this;
+    }
+
+    SampleLocationsInfoEXT & setSampleLocationGridSize( Extent2D sampleLocationGridSize_ )
+    {
+      sampleLocationGridSize = sampleLocationGridSize_;
+      return *this;
+    }
+
+    SampleLocationsInfoEXT & setSampleLocationsCount( uint32_t sampleLocationsCount_ )
+    {
+      sampleLocationsCount = sampleLocationsCount_;
+      return *this;
+    }
+
+    SampleLocationsInfoEXT & setPSampleLocations( const SampleLocationEXT* pSampleLocations_ )
+    {
+      pSampleLocations = pSampleLocations_;
+      return *this;
+    }
+
+    operator VkSampleLocationsInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkSampleLocationsInfoEXT*>( this );
+    }
+
+    operator VkSampleLocationsInfoEXT &()
+    {
+      return *reinterpret_cast<VkSampleLocationsInfoEXT*>( this );
+    }
+
+    bool operator==( SampleLocationsInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel )
+          && ( sampleLocationGridSize == rhs.sampleLocationGridSize )
+          && ( sampleLocationsCount == rhs.sampleLocationsCount )
+          && ( pSampleLocations == rhs.pSampleLocations );
+    }
+
+    bool operator!=( SampleLocationsInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSampleLocationsInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    SampleCountFlagBits sampleLocationsPerPixel;
+    Extent2D sampleLocationGridSize;
+    uint32_t sampleLocationsCount;
+    const SampleLocationEXT* pSampleLocations;
+  };
+  static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" );
+
+  struct AttachmentSampleLocationsEXT
+  {
+    AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = 0,
+                                  SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
+      : attachmentIndex( attachmentIndex_ )
+      , sampleLocationsInfo( sampleLocationsInfo_ )
+    {}
+
+    AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
+    }
+
+    AttachmentSampleLocationsEXT& operator=( VkAttachmentSampleLocationsEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
+      return *this;
+    }
+
+    AttachmentSampleLocationsEXT & setAttachmentIndex( uint32_t attachmentIndex_ )
+    {
+      attachmentIndex = attachmentIndex_;
+      return *this;
+    }
+
+    AttachmentSampleLocationsEXT & setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+    {
+      sampleLocationsInfo = sampleLocationsInfo_;
+      return *this;
+    }
+
+    operator VkAttachmentSampleLocationsEXT const&() const
+    {
+      return *reinterpret_cast<const VkAttachmentSampleLocationsEXT*>( this );
+    }
+
+    operator VkAttachmentSampleLocationsEXT &()
+    {
+      return *reinterpret_cast<VkAttachmentSampleLocationsEXT*>( this );
+    }
+
+    bool operator==( AttachmentSampleLocationsEXT const& rhs ) const
+    {
+      return ( attachmentIndex == rhs.attachmentIndex )
+          && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+    }
+
+    bool operator!=( AttachmentSampleLocationsEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t attachmentIndex;
+    SampleLocationsInfoEXT sampleLocationsInfo;
+  };
+  static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" );
+
+  struct BaseInStructure
+  {
+    BaseInStructure(  )
+    {}
+
+    BaseInStructure( VkBaseInStructure const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BaseInStructure ) );
+    }
+
+    BaseInStructure& operator=( VkBaseInStructure const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BaseInStructure ) );
+      return *this;
+    }
+
+    BaseInStructure & setPNext( const struct BaseInStructure* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    operator VkBaseInStructure const&() const
+    {
+      return *reinterpret_cast<const VkBaseInStructure*>( this );
+    }
+
+    operator VkBaseInStructure &()
+    {
+      return *reinterpret_cast<VkBaseInStructure*>( this );
+    }
+
+    bool operator==( BaseInStructure const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext );
+    }
+
+    bool operator!=( BaseInStructure const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    StructureType sType;
+    const struct BaseInStructure* pNext = nullptr;
+  };
+  static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" );
+
+  struct BaseOutStructure
+  {
+    BaseOutStructure(  )
+    {}
+
+    BaseOutStructure( VkBaseOutStructure const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BaseOutStructure ) );
+    }
+
+    BaseOutStructure& operator=( VkBaseOutStructure const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BaseOutStructure ) );
+      return *this;
+    }
+
+    BaseOutStructure & setPNext( struct BaseOutStructure* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    operator VkBaseOutStructure const&() const
+    {
+      return *reinterpret_cast<const VkBaseOutStructure*>( this );
+    }
+
+    operator VkBaseOutStructure &()
+    {
+      return *reinterpret_cast<VkBaseOutStructure*>( this );
+    }
+
+    bool operator==( BaseOutStructure const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext );
+    }
+
+    bool operator!=( BaseOutStructure const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    StructureType sType;
+    struct BaseOutStructure* pNext = nullptr;
+  };
+  static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "struct and wrapper have different size!" );
+
+  struct BindAccelerationStructureMemoryInfoNV
+  {
+    BindAccelerationStructureMemoryInfoNV( AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV(),
+                                           DeviceMemory memory_ = DeviceMemory(),
+                                           DeviceSize memoryOffset_ = 0,
+                                           uint32_t deviceIndexCount_ = 0,
+                                           const uint32_t* pDeviceIndices_ = nullptr )
+      : accelerationStructure( accelerationStructure_ )
+      , memory( memory_ )
+      , memoryOffset( memoryOffset_ )
+      , deviceIndexCount( deviceIndexCount_ )
+      , pDeviceIndices( pDeviceIndices_ )
+    {}
+
+    BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) );
+    }
+
+    BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) );
+      return *this;
+    }
+
+    BindAccelerationStructureMemoryInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    BindAccelerationStructureMemoryInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ )
+    {
+      accelerationStructure = accelerationStructure_;
+      return *this;
+    }
+
+    BindAccelerationStructureMemoryInfoNV & setMemory( DeviceMemory memory_ )
     {
       memory = memory_;
       return *this;
     }
 
-    MappedMemoryRange& setOffset( DeviceSize offset_ )
+    BindAccelerationStructureMemoryInfoNV & setMemoryOffset( DeviceSize memoryOffset_ )
     {
-      offset = offset_;
+      memoryOffset = memoryOffset_;
       return *this;
     }
 
-    MappedMemoryRange& setSize( DeviceSize size_ )
+    BindAccelerationStructureMemoryInfoNV & setDeviceIndexCount( uint32_t deviceIndexCount_ )
     {
-      size = size_;
+      deviceIndexCount = deviceIndexCount_;
       return *this;
     }
 
-    operator VkMappedMemoryRange const&() const
+    BindAccelerationStructureMemoryInfoNV & setPDeviceIndices( const uint32_t* pDeviceIndices_ )
     {
-      return *reinterpret_cast<const VkMappedMemoryRange*>(this);
+      pDeviceIndices = pDeviceIndices_;
+      return *this;
     }
 
-    operator VkMappedMemoryRange &()
+    operator VkBindAccelerationStructureMemoryInfoNV const&() const
     {
-      return *reinterpret_cast<VkMappedMemoryRange*>(this);
+      return *reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>( this );
     }
 
-    bool operator==( MappedMemoryRange const& rhs ) const
+    operator VkBindAccelerationStructureMemoryInfoNV &()
+    {
+      return *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV*>( this );
+    }
+
+    bool operator==( BindAccelerationStructureMemoryInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
+          && ( accelerationStructure == rhs.accelerationStructure )
           && ( memory == rhs.memory )
-          && ( offset == rhs.offset )
-          && ( size == rhs.size );
+          && ( memoryOffset == rhs.memoryOffset )
+          && ( deviceIndexCount == rhs.deviceIndexCount )
+          && ( pDeviceIndices == rhs.pDeviceIndices );
     }
 
-    bool operator!=( MappedMemoryRange const& rhs ) const
+    bool operator!=( BindAccelerationStructureMemoryInfoNV const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eMappedMemoryRange;
+    StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV;
 
   public:
     const void* pNext = nullptr;
+    AccelerationStructureNV accelerationStructure;
     DeviceMemory memory;
-    DeviceSize offset;
-    DeviceSize size;
+    DeviceSize memoryOffset;
+    uint32_t deviceIndexCount;
+    const uint32_t* pDeviceIndices;
   };
-  static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" );
+  static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "struct and wrapper have different size!" );
 
-  struct WriteDescriptorSet
+  struct BindBufferMemoryDeviceGroupInfo
   {
-    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 )
-      : dstSet( dstSet_ )
-      , dstBinding( dstBinding_ )
-      , dstArrayElement( dstArrayElement_ )
-      , descriptorCount( descriptorCount_ )
-      , descriptorType( descriptorType_ )
-      , pImageInfo( pImageInfo_ )
-      , pBufferInfo( pBufferInfo_ )
-      , pTexelBufferView( pTexelBufferView_ )
+    BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
+                                     const uint32_t* pDeviceIndices_ = nullptr )
+      : deviceIndexCount( deviceIndexCount_ )
+      , pDeviceIndices( pDeviceIndices_ )
+    {}
+
+    BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs )
     {
+      memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfo ) );
     }
 
-    WriteDescriptorSet( VkWriteDescriptorSet const & rhs )
+    BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs )
     {
-      memcpy( this, &rhs, sizeof( WriteDescriptorSet ) );
-    }
-
-    WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( WriteDescriptorSet ) );
+      memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfo ) );
       return *this;
     }
-    WriteDescriptorSet& setPNext( const void* pNext_ )
+
+    BindBufferMemoryDeviceGroupInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    WriteDescriptorSet& setDstSet( DescriptorSet dstSet_ )
+    BindBufferMemoryDeviceGroupInfo & setDeviceIndexCount( uint32_t deviceIndexCount_ )
     {
-      dstSet = dstSet_;
+      deviceIndexCount = deviceIndexCount_;
       return *this;
     }
 
-    WriteDescriptorSet& setDstBinding( uint32_t dstBinding_ )
+    BindBufferMemoryDeviceGroupInfo & setPDeviceIndices( const uint32_t* pDeviceIndices_ )
     {
-      dstBinding = dstBinding_;
+      pDeviceIndices = pDeviceIndices_;
       return *this;
     }
 
-    WriteDescriptorSet& setDstArrayElement( uint32_t dstArrayElement_ )
+    operator VkBindBufferMemoryDeviceGroupInfo const&() const
     {
-      dstArrayElement = dstArrayElement_;
-      return *this;
+      return *reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>( this );
     }
 
-    WriteDescriptorSet& setDescriptorCount( uint32_t descriptorCount_ )
+    operator VkBindBufferMemoryDeviceGroupInfo &()
     {
-      descriptorCount = descriptorCount_;
-      return *this;
+      return *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>( this );
     }
 
-    WriteDescriptorSet& setDescriptorType( DescriptorType descriptorType_ )
-    {
-      descriptorType = descriptorType_;
-      return *this;
-    }
-
-    WriteDescriptorSet& setPImageInfo( const DescriptorImageInfo* pImageInfo_ )
-    {
-      pImageInfo = pImageInfo_;
-      return *this;
-    }
-
-    WriteDescriptorSet& setPBufferInfo( const DescriptorBufferInfo* pBufferInfo_ )
-    {
-      pBufferInfo = pBufferInfo_;
-      return *this;
-    }
-
-    WriteDescriptorSet& setPTexelBufferView( const BufferView* pTexelBufferView_ )
-    {
-      pTexelBufferView = pTexelBufferView_;
-      return *this;
-    }
-
-    operator VkWriteDescriptorSet const&() const
-    {
-      return *reinterpret_cast<const VkWriteDescriptorSet*>(this);
-    }
-
-    operator VkWriteDescriptorSet &()
-    {
-      return *reinterpret_cast<VkWriteDescriptorSet*>(this);
-    }
-
-    bool operator==( WriteDescriptorSet const& rhs ) const
+    bool operator==( BindBufferMemoryDeviceGroupInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( dstSet == rhs.dstSet )
-          && ( dstBinding == rhs.dstBinding )
-          && ( dstArrayElement == rhs.dstArrayElement )
-          && ( descriptorCount == rhs.descriptorCount )
-          && ( descriptorType == rhs.descriptorType )
-          && ( pImageInfo == rhs.pImageInfo )
-          && ( pBufferInfo == rhs.pBufferInfo )
-          && ( pTexelBufferView == rhs.pTexelBufferView );
+          && ( deviceIndexCount == rhs.deviceIndexCount )
+          && ( pDeviceIndices == rhs.pDeviceIndices );
     }
 
-    bool operator!=( WriteDescriptorSet const& rhs ) const
+    bool operator!=( BindBufferMemoryDeviceGroupInfo const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eWriteDescriptorSet;
+    StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo;
 
   public:
     const void* pNext = nullptr;
-    DescriptorSet dstSet;
-    uint32_t dstBinding;
-    uint32_t dstArrayElement;
-    uint32_t descriptorCount;
-    DescriptorType descriptorType;
-    const DescriptorImageInfo* pImageInfo;
-    const DescriptorBufferInfo* pBufferInfo;
-    const BufferView* pTexelBufferView;
+    uint32_t deviceIndexCount;
+    const uint32_t* pDeviceIndices;
   };
-  static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" );
+  static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "struct and wrapper have different size!" );
+
+  struct BindBufferMemoryInfo
+  {
+    BindBufferMemoryInfo( Buffer buffer_ = Buffer(),
+                          DeviceMemory memory_ = DeviceMemory(),
+                          DeviceSize memoryOffset_ = 0 )
+      : buffer( buffer_ )
+      , memory( memory_ )
+      , memoryOffset( memoryOffset_ )
+    {}
+
+    BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindBufferMemoryInfo ) );
+    }
+
+    BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindBufferMemoryInfo ) );
+      return *this;
+    }
+
+    BindBufferMemoryInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    BindBufferMemoryInfo & setBuffer( Buffer buffer_ )
+    {
+      buffer = buffer_;
+      return *this;
+    }
+
+    BindBufferMemoryInfo & setMemory( DeviceMemory memory_ )
+    {
+      memory = memory_;
+      return *this;
+    }
+
+    BindBufferMemoryInfo & setMemoryOffset( DeviceSize memoryOffset_ )
+    {
+      memoryOffset = memoryOffset_;
+      return *this;
+    }
+
+    operator VkBindBufferMemoryInfo const&() const
+    {
+      return *reinterpret_cast<const VkBindBufferMemoryInfo*>( this );
+    }
+
+    operator VkBindBufferMemoryInfo &()
+    {
+      return *reinterpret_cast<VkBindBufferMemoryInfo*>( this );
+    }
+
+    bool operator==( BindBufferMemoryInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( buffer == rhs.buffer )
+          && ( memory == rhs.memory )
+          && ( memoryOffset == rhs.memoryOffset );
+    }
+
+    bool operator!=( BindBufferMemoryInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eBindBufferMemoryInfo;
+
+  public:
+    const void* pNext = nullptr;
+    Buffer buffer;
+    DeviceMemory memory;
+    DeviceSize memoryOffset;
+  };
+  static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "struct and wrapper have different size!" );
+
+  struct Offset2D
+  {
+    Offset2D( int32_t x_ = 0,
+              int32_t y_ = 0 )
+      : x( x_ )
+      , y( y_ )
+    {}
+
+    Offset2D( VkOffset2D const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Offset2D ) );
+    }
+
+    Offset2D& operator=( VkOffset2D const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Offset2D ) );
+      return *this;
+    }
+
+    Offset2D & setX( int32_t x_ )
+    {
+      x = x_;
+      return *this;
+    }
+
+    Offset2D & setY( int32_t y_ )
+    {
+      y = y_;
+      return *this;
+    }
+
+    operator VkOffset2D const&() const
+    {
+      return *reinterpret_cast<const VkOffset2D*>( this );
+    }
+
+    operator VkOffset2D &()
+    {
+      return *reinterpret_cast<VkOffset2D*>( this );
+    }
+
+    bool operator==( Offset2D const& rhs ) const
+    {
+      return ( x == rhs.x )
+          && ( y == rhs.y );
+    }
+
+    bool operator!=( Offset2D const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    int32_t x;
+    int32_t y;
+  };
+  static_assert( sizeof( Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" );
+
+  struct Rect2D
+  {
+    Rect2D( Offset2D offset_ = Offset2D(),
+            Extent2D extent_ = Extent2D() )
+      : offset( offset_ )
+      , extent( extent_ )
+    {}
+
+    Rect2D( VkRect2D const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Rect2D ) );
+    }
+
+    Rect2D& operator=( VkRect2D const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Rect2D ) );
+      return *this;
+    }
+
+    Rect2D & setOffset( Offset2D offset_ )
+    {
+      offset = offset_;
+      return *this;
+    }
+
+    Rect2D & setExtent( Extent2D extent_ )
+    {
+      extent = extent_;
+      return *this;
+    }
+
+    operator VkRect2D const&() const
+    {
+      return *reinterpret_cast<const VkRect2D*>( this );
+    }
+
+    operator VkRect2D &()
+    {
+      return *reinterpret_cast<VkRect2D*>( this );
+    }
+
+    bool operator==( Rect2D const& rhs ) const
+    {
+      return ( offset == rhs.offset )
+          && ( extent == rhs.extent );
+    }
+
+    bool operator!=( Rect2D const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    Offset2D offset;
+    Extent2D extent;
+  };
+  static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" );
+
+  struct BindImageMemoryDeviceGroupInfo
+  {
+    BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
+                                    const uint32_t* pDeviceIndices_ = nullptr,
+                                    uint32_t splitInstanceBindRegionCount_ = 0,
+                                    const Rect2D* pSplitInstanceBindRegions_ = nullptr )
+      : deviceIndexCount( deviceIndexCount_ )
+      , pDeviceIndices( pDeviceIndices_ )
+      , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ )
+      , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ )
+    {}
+
+    BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfo ) );
+    }
+
+    BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfo ) );
+      return *this;
+    }
+
+    BindImageMemoryDeviceGroupInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    BindImageMemoryDeviceGroupInfo & setDeviceIndexCount( uint32_t deviceIndexCount_ )
+    {
+      deviceIndexCount = deviceIndexCount_;
+      return *this;
+    }
+
+    BindImageMemoryDeviceGroupInfo & setPDeviceIndices( const uint32_t* pDeviceIndices_ )
+    {
+      pDeviceIndices = pDeviceIndices_;
+      return *this;
+    }
+
+    BindImageMemoryDeviceGroupInfo & setSplitInstanceBindRegionCount( uint32_t splitInstanceBindRegionCount_ )
+    {
+      splitInstanceBindRegionCount = splitInstanceBindRegionCount_;
+      return *this;
+    }
+
+    BindImageMemoryDeviceGroupInfo & setPSplitInstanceBindRegions( const Rect2D* pSplitInstanceBindRegions_ )
+    {
+      pSplitInstanceBindRegions = pSplitInstanceBindRegions_;
+      return *this;
+    }
+
+    operator VkBindImageMemoryDeviceGroupInfo const&() const
+    {
+      return *reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>( this );
+    }
+
+    operator VkBindImageMemoryDeviceGroupInfo &()
+    {
+      return *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>( this );
+    }
+
+    bool operator==( BindImageMemoryDeviceGroupInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( deviceIndexCount == rhs.deviceIndexCount )
+          && ( pDeviceIndices == rhs.pDeviceIndices )
+          && ( splitInstanceBindRegionCount == rhs.splitInstanceBindRegionCount )
+          && ( pSplitInstanceBindRegions == rhs.pSplitInstanceBindRegions );
+    }
+
+    bool operator!=( BindImageMemoryDeviceGroupInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t deviceIndexCount;
+    const uint32_t* pDeviceIndices;
+    uint32_t splitInstanceBindRegionCount;
+    const Rect2D* pSplitInstanceBindRegions;
+  };
+  static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "struct and wrapper have different size!" );
+
+  struct BindImageMemoryInfo
+  {
+    BindImageMemoryInfo( Image image_ = Image(),
+                         DeviceMemory memory_ = DeviceMemory(),
+                         DeviceSize memoryOffset_ = 0 )
+      : image( image_ )
+      , memory( memory_ )
+      , memoryOffset( memoryOffset_ )
+    {}
+
+    BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindImageMemoryInfo ) );
+    }
+
+    BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindImageMemoryInfo ) );
+      return *this;
+    }
+
+    BindImageMemoryInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    BindImageMemoryInfo & setImage( Image image_ )
+    {
+      image = image_;
+      return *this;
+    }
+
+    BindImageMemoryInfo & setMemory( DeviceMemory memory_ )
+    {
+      memory = memory_;
+      return *this;
+    }
+
+    BindImageMemoryInfo & setMemoryOffset( DeviceSize memoryOffset_ )
+    {
+      memoryOffset = memoryOffset_;
+      return *this;
+    }
+
+    operator VkBindImageMemoryInfo const&() const
+    {
+      return *reinterpret_cast<const VkBindImageMemoryInfo*>( this );
+    }
+
+    operator VkBindImageMemoryInfo &()
+    {
+      return *reinterpret_cast<VkBindImageMemoryInfo*>( this );
+    }
+
+    bool operator==( BindImageMemoryInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( image == rhs.image )
+          && ( memory == rhs.memory )
+          && ( memoryOffset == rhs.memoryOffset );
+    }
+
+    bool operator!=( BindImageMemoryInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eBindImageMemoryInfo;
+
+  public:
+    const void* pNext = nullptr;
+    Image image;
+    DeviceMemory memory;
+    DeviceSize memoryOffset;
+  };
+  static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "struct and wrapper have different size!" );
+
+  struct BindImageMemorySwapchainInfoKHR
+  {
+    BindImageMemorySwapchainInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR(),
+                                     uint32_t imageIndex_ = 0 )
+      : swapchain( swapchain_ )
+      , imageIndex( imageIndex_ )
+    {}
+
+    BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHR ) );
+    }
+
+    BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHR ) );
+      return *this;
+    }
+
+    BindImageMemorySwapchainInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    BindImageMemorySwapchainInfoKHR & setSwapchain( SwapchainKHR swapchain_ )
+    {
+      swapchain = swapchain_;
+      return *this;
+    }
+
+    BindImageMemorySwapchainInfoKHR & setImageIndex( uint32_t imageIndex_ )
+    {
+      imageIndex = imageIndex_;
+      return *this;
+    }
+
+    operator VkBindImageMemorySwapchainInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>( this );
+    }
+
+    operator VkBindImageMemorySwapchainInfoKHR &()
+    {
+      return *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>( this );
+    }
+
+    bool operator==( BindImageMemorySwapchainInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( swapchain == rhs.swapchain )
+          && ( imageIndex == rhs.imageIndex );
+    }
+
+    bool operator!=( BindImageMemorySwapchainInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    SwapchainKHR swapchain;
+    uint32_t imageIndex;
+  };
+  static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "struct and wrapper have different size!" );
+
+  struct BindImagePlaneMemoryInfo
+  {
+    BindImagePlaneMemoryInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
+      : planeAspect( planeAspect_ )
+    {}
+
+    BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) );
+    }
+
+    BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) );
+      return *this;
+    }
+
+    BindImagePlaneMemoryInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    BindImagePlaneMemoryInfo & setPlaneAspect( ImageAspectFlagBits planeAspect_ )
+    {
+      planeAspect = planeAspect_;
+      return *this;
+    }
+
+    operator VkBindImagePlaneMemoryInfo const&() const
+    {
+      return *reinterpret_cast<const VkBindImagePlaneMemoryInfo*>( this );
+    }
+
+    operator VkBindImagePlaneMemoryInfo &()
+    {
+      return *reinterpret_cast<VkBindImagePlaneMemoryInfo*>( this );
+    }
+
+    bool operator==( BindImagePlaneMemoryInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( planeAspect == rhs.planeAspect );
+    }
+
+    bool operator!=( BindImagePlaneMemoryInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eBindImagePlaneMemoryInfo;
+
+  public:
+    const void* pNext = nullptr;
+    ImageAspectFlagBits planeAspect;
+  };
+  static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "struct and wrapper have different size!" );
+
+  struct SparseMemoryBind
+  {
+    SparseMemoryBind( DeviceSize resourceOffset_ = 0,
+                      DeviceSize size_ = 0,
+                      DeviceMemory memory_ = DeviceMemory(),
+                      DeviceSize memoryOffset_ = 0,
+                      SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
+      : resourceOffset( resourceOffset_ )
+      , size( size_ )
+      , memory( memory_ )
+      , memoryOffset( memoryOffset_ )
+      , flags( flags_ )
+    {}
+
+    SparseMemoryBind( VkSparseMemoryBind const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
+    }
+
+    SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
+      return *this;
+    }
+
+    SparseMemoryBind & setResourceOffset( DeviceSize resourceOffset_ )
+    {
+      resourceOffset = resourceOffset_;
+      return *this;
+    }
+
+    SparseMemoryBind & setSize( DeviceSize size_ )
+    {
+      size = size_;
+      return *this;
+    }
+
+    SparseMemoryBind & setMemory( DeviceMemory memory_ )
+    {
+      memory = memory_;
+      return *this;
+    }
+
+    SparseMemoryBind & setMemoryOffset( DeviceSize memoryOffset_ )
+    {
+      memoryOffset = memoryOffset_;
+      return *this;
+    }
+
+    SparseMemoryBind & setFlags( SparseMemoryBindFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    operator VkSparseMemoryBind const&() const
+    {
+      return *reinterpret_cast<const VkSparseMemoryBind*>( this );
+    }
+
+    operator VkSparseMemoryBind &()
+    {
+      return *reinterpret_cast<VkSparseMemoryBind*>( this );
+    }
+
+    bool operator==( SparseMemoryBind const& rhs ) const
+    {
+      return ( resourceOffset == rhs.resourceOffset )
+          && ( size == rhs.size )
+          && ( memory == rhs.memory )
+          && ( memoryOffset == rhs.memoryOffset )
+          && ( flags == rhs.flags );
+    }
+
+    bool operator!=( SparseMemoryBind const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    DeviceSize resourceOffset;
+    DeviceSize size;
+    DeviceMemory memory;
+    DeviceSize memoryOffset;
+    SparseMemoryBindFlags flags;
+  };
+  static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" );
+
+  struct SparseBufferMemoryBindInfo
+  {
+    SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(),
+                                uint32_t bindCount_ = 0,
+                                const SparseMemoryBind* pBinds_ = nullptr )
+      : buffer( buffer_ )
+      , bindCount( bindCount_ )
+      , pBinds( pBinds_ )
+    {}
+
+    SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
+    }
+
+    SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
+      return *this;
+    }
+
+    SparseBufferMemoryBindInfo & setBuffer( Buffer buffer_ )
+    {
+      buffer = buffer_;
+      return *this;
+    }
+
+    SparseBufferMemoryBindInfo & setBindCount( uint32_t bindCount_ )
+    {
+      bindCount = bindCount_;
+      return *this;
+    }
+
+    SparseBufferMemoryBindInfo & setPBinds( const SparseMemoryBind* pBinds_ )
+    {
+      pBinds = pBinds_;
+      return *this;
+    }
+
+    operator VkSparseBufferMemoryBindInfo const&() const
+    {
+      return *reinterpret_cast<const VkSparseBufferMemoryBindInfo*>( this );
+    }
+
+    operator VkSparseBufferMemoryBindInfo &()
+    {
+      return *reinterpret_cast<VkSparseBufferMemoryBindInfo*>( this );
+    }
+
+    bool operator==( SparseBufferMemoryBindInfo const& rhs ) const
+    {
+      return ( buffer == rhs.buffer )
+          && ( bindCount == rhs.bindCount )
+          && ( pBinds == rhs.pBinds );
+    }
+
+    bool operator!=( SparseBufferMemoryBindInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    Buffer buffer;
+    uint32_t bindCount;
+    const SparseMemoryBind* pBinds;
+  };
+  static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" );
+
+  struct SparseImageOpaqueMemoryBindInfo
+  {
+    SparseImageOpaqueMemoryBindInfo( Image image_ = Image(),
+                                     uint32_t bindCount_ = 0,
+                                     const SparseMemoryBind* pBinds_ = nullptr )
+      : image( image_ )
+      , bindCount( bindCount_ )
+      , pBinds( pBinds_ )
+    {}
+
+    SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
+    }
+
+    SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
+      return *this;
+    }
+
+    SparseImageOpaqueMemoryBindInfo & setImage( Image image_ )
+    {
+      image = image_;
+      return *this;
+    }
+
+    SparseImageOpaqueMemoryBindInfo & setBindCount( uint32_t bindCount_ )
+    {
+      bindCount = bindCount_;
+      return *this;
+    }
+
+    SparseImageOpaqueMemoryBindInfo & setPBinds( const SparseMemoryBind* pBinds_ )
+    {
+      pBinds = pBinds_;
+      return *this;
+    }
+
+    operator VkSparseImageOpaqueMemoryBindInfo const&() const
+    {
+      return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>( this );
+    }
+
+    operator VkSparseImageOpaqueMemoryBindInfo &()
+    {
+      return *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>( this );
+    }
+
+    bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const
+    {
+      return ( image == rhs.image )
+          && ( bindCount == rhs.bindCount )
+          && ( pBinds == rhs.pBinds );
+    }
+
+    bool operator!=( SparseImageOpaqueMemoryBindInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    Image image;
+    uint32_t bindCount;
+    const SparseMemoryBind* pBinds;
+  };
+  static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" );
+
+  struct ImageSubresource
+  {
+    ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
+                      uint32_t mipLevel_ = 0,
+                      uint32_t arrayLayer_ = 0 )
+      : aspectMask( aspectMask_ )
+      , mipLevel( mipLevel_ )
+      , arrayLayer( arrayLayer_ )
+    {}
+
+    ImageSubresource( VkImageSubresource const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageSubresource ) );
+    }
+
+    ImageSubresource& operator=( VkImageSubresource const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageSubresource ) );
+      return *this;
+    }
+
+    ImageSubresource & setAspectMask( ImageAspectFlags aspectMask_ )
+    {
+      aspectMask = aspectMask_;
+      return *this;
+    }
+
+    ImageSubresource & setMipLevel( uint32_t mipLevel_ )
+    {
+      mipLevel = mipLevel_;
+      return *this;
+    }
+
+    ImageSubresource & setArrayLayer( uint32_t arrayLayer_ )
+    {
+      arrayLayer = arrayLayer_;
+      return *this;
+    }
+
+    operator VkImageSubresource const&() const
+    {
+      return *reinterpret_cast<const VkImageSubresource*>( this );
+    }
+
+    operator VkImageSubresource &()
+    {
+      return *reinterpret_cast<VkImageSubresource*>( this );
+    }
+
+    bool operator==( ImageSubresource const& rhs ) const
+    {
+      return ( aspectMask == rhs.aspectMask )
+          && ( mipLevel == rhs.mipLevel )
+          && ( arrayLayer == rhs.arrayLayer );
+    }
+
+    bool operator!=( ImageSubresource const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ImageAspectFlags aspectMask;
+    uint32_t mipLevel;
+    uint32_t arrayLayer;
+  };
+  static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" );
+
+  struct Offset3D
+  {
+    Offset3D( int32_t x_ = 0,
+              int32_t y_ = 0,
+              int32_t z_ = 0 )
+      : x( x_ )
+      , y( y_ )
+      , z( z_ )
+    {}
+
+    explicit Offset3D( Offset2D const& offset2D,
+                       int32_t z_ = 0 )
+      : x( offset2D.x )
+      , y( offset2D.y )
+      , z( z_ )
+    {}
+
+    Offset3D( VkOffset3D const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Offset3D ) );
+    }
+
+    Offset3D& operator=( VkOffset3D const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Offset3D ) );
+      return *this;
+    }
+
+    Offset3D & setX( int32_t x_ )
+    {
+      x = x_;
+      return *this;
+    }
+
+    Offset3D & setY( int32_t y_ )
+    {
+      y = y_;
+      return *this;
+    }
+
+    Offset3D & setZ( int32_t z_ )
+    {
+      z = z_;
+      return *this;
+    }
+
+    operator VkOffset3D const&() const
+    {
+      return *reinterpret_cast<const VkOffset3D*>( this );
+    }
+
+    operator VkOffset3D &()
+    {
+      return *reinterpret_cast<VkOffset3D*>( this );
+    }
+
+    bool operator==( Offset3D const& rhs ) const
+    {
+      return ( x == rhs.x )
+          && ( y == rhs.y )
+          && ( z == rhs.z );
+    }
+
+    bool operator!=( Offset3D const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    int32_t x;
+    int32_t y;
+    int32_t z;
+  };
+  static_assert( sizeof( Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" );
+
+  struct Extent3D
+  {
+    Extent3D( uint32_t width_ = 0,
+              uint32_t height_ = 0,
+              uint32_t depth_ = 0 )
+      : width( width_ )
+      , height( height_ )
+      , depth( depth_ )
+    {}
+
+    explicit Extent3D( Extent2D const& extent2D,
+                       uint32_t depth_ = 0 )
+      : width( extent2D.width )
+      , height( extent2D.height )
+      , depth( depth_ )
+    {}
+
+    Extent3D( VkExtent3D const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Extent3D ) );
+    }
+
+    Extent3D& operator=( VkExtent3D const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Extent3D ) );
+      return *this;
+    }
+
+    Extent3D & setWidth( uint32_t width_ )
+    {
+      width = width_;
+      return *this;
+    }
+
+    Extent3D & setHeight( uint32_t height_ )
+    {
+      height = height_;
+      return *this;
+    }
+
+    Extent3D & setDepth( uint32_t depth_ )
+    {
+      depth = depth_;
+      return *this;
+    }
+
+    operator VkExtent3D const&() const
+    {
+      return *reinterpret_cast<const VkExtent3D*>( this );
+    }
+
+    operator VkExtent3D &()
+    {
+      return *reinterpret_cast<VkExtent3D*>( this );
+    }
+
+    bool operator==( Extent3D const& rhs ) const
+    {
+      return ( width == rhs.width )
+          && ( height == rhs.height )
+          && ( depth == rhs.depth );
+    }
+
+    bool operator!=( Extent3D const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t width;
+    uint32_t height;
+    uint32_t depth;
+  };
+  static_assert( sizeof( Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" );
+
+  struct SparseImageMemoryBind
+  {
+    SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(),
+                           Offset3D offset_ = Offset3D(),
+                           Extent3D extent_ = Extent3D(),
+                           DeviceMemory memory_ = DeviceMemory(),
+                           DeviceSize memoryOffset_ = 0,
+                           SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
+      : subresource( subresource_ )
+      , offset( offset_ )
+      , extent( extent_ )
+      , memory( memory_ )
+      , memoryOffset( memoryOffset_ )
+      , flags( flags_ )
+    {}
+
+    SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
+    }
+
+    SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
+      return *this;
+    }
+
+    SparseImageMemoryBind & setSubresource( ImageSubresource subresource_ )
+    {
+      subresource = subresource_;
+      return *this;
+    }
+
+    SparseImageMemoryBind & setOffset( Offset3D offset_ )
+    {
+      offset = offset_;
+      return *this;
+    }
+
+    SparseImageMemoryBind & setExtent( Extent3D extent_ )
+    {
+      extent = extent_;
+      return *this;
+    }
+
+    SparseImageMemoryBind & setMemory( DeviceMemory memory_ )
+    {
+      memory = memory_;
+      return *this;
+    }
+
+    SparseImageMemoryBind & setMemoryOffset( DeviceSize memoryOffset_ )
+    {
+      memoryOffset = memoryOffset_;
+      return *this;
+    }
+
+    SparseImageMemoryBind & setFlags( SparseMemoryBindFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    operator VkSparseImageMemoryBind const&() const
+    {
+      return *reinterpret_cast<const VkSparseImageMemoryBind*>( this );
+    }
+
+    operator VkSparseImageMemoryBind &()
+    {
+      return *reinterpret_cast<VkSparseImageMemoryBind*>( this );
+    }
+
+    bool operator==( SparseImageMemoryBind const& rhs ) const
+    {
+      return ( subresource == rhs.subresource )
+          && ( offset == rhs.offset )
+          && ( extent == rhs.extent )
+          && ( memory == rhs.memory )
+          && ( memoryOffset == rhs.memoryOffset )
+          && ( flags == rhs.flags );
+    }
+
+    bool operator!=( SparseImageMemoryBind const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ImageSubresource subresource;
+    Offset3D offset;
+    Extent3D extent;
+    DeviceMemory memory;
+    DeviceSize memoryOffset;
+    SparseMemoryBindFlags flags;
+  };
+  static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" );
+
+  struct SparseImageMemoryBindInfo
+  {
+    SparseImageMemoryBindInfo( Image image_ = Image(),
+                               uint32_t bindCount_ = 0,
+                               const SparseImageMemoryBind* pBinds_ = nullptr )
+      : image( image_ )
+      , bindCount( bindCount_ )
+      , pBinds( pBinds_ )
+    {}
+
+    SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
+    }
+
+    SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
+      return *this;
+    }
+
+    SparseImageMemoryBindInfo & setImage( Image image_ )
+    {
+      image = image_;
+      return *this;
+    }
+
+    SparseImageMemoryBindInfo & setBindCount( uint32_t bindCount_ )
+    {
+      bindCount = bindCount_;
+      return *this;
+    }
+
+    SparseImageMemoryBindInfo & setPBinds( const SparseImageMemoryBind* pBinds_ )
+    {
+      pBinds = pBinds_;
+      return *this;
+    }
+
+    operator VkSparseImageMemoryBindInfo const&() const
+    {
+      return *reinterpret_cast<const VkSparseImageMemoryBindInfo*>( this );
+    }
+
+    operator VkSparseImageMemoryBindInfo &()
+    {
+      return *reinterpret_cast<VkSparseImageMemoryBindInfo*>( this );
+    }
+
+    bool operator==( SparseImageMemoryBindInfo const& rhs ) const
+    {
+      return ( image == rhs.image )
+          && ( bindCount == rhs.bindCount )
+          && ( pBinds == rhs.pBinds );
+    }
+
+    bool operator!=( SparseImageMemoryBindInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    Image image;
+    uint32_t bindCount;
+    const SparseImageMemoryBind* pBinds;
+  };
+  static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" );
+
+  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 )
+      : waitSemaphoreCount( waitSemaphoreCount_ )
+      , pWaitSemaphores( pWaitSemaphores_ )
+      , bufferBindCount( bufferBindCount_ )
+      , pBufferBinds( pBufferBinds_ )
+      , imageOpaqueBindCount( imageOpaqueBindCount_ )
+      , pImageOpaqueBinds( pImageOpaqueBinds_ )
+      , imageBindCount( imageBindCount_ )
+      , pImageBinds( pImageBinds_ )
+      , signalSemaphoreCount( signalSemaphoreCount_ )
+      , pSignalSemaphores( pSignalSemaphores_ )
+    {}
+
+    BindSparseInfo( VkBindSparseInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindSparseInfo ) );
+    }
+
+    BindSparseInfo& operator=( VkBindSparseInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BindSparseInfo ) );
+      return *this;
+    }
+
+    BindSparseInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    BindSparseInfo & setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
+    {
+      waitSemaphoreCount = waitSemaphoreCount_;
+      return *this;
+    }
+
+    BindSparseInfo & setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+    {
+      pWaitSemaphores = pWaitSemaphores_;
+      return *this;
+    }
+
+    BindSparseInfo & setBufferBindCount( uint32_t bufferBindCount_ )
+    {
+      bufferBindCount = bufferBindCount_;
+      return *this;
+    }
+
+    BindSparseInfo & setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ )
+    {
+      pBufferBinds = pBufferBinds_;
+      return *this;
+    }
+
+    BindSparseInfo & setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ )
+    {
+      imageOpaqueBindCount = imageOpaqueBindCount_;
+      return *this;
+    }
+
+    BindSparseInfo & setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ )
+    {
+      pImageOpaqueBinds = pImageOpaqueBinds_;
+      return *this;
+    }
+
+    BindSparseInfo & setImageBindCount( uint32_t imageBindCount_ )
+    {
+      imageBindCount = imageBindCount_;
+      return *this;
+    }
+
+    BindSparseInfo & setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ )
+    {
+      pImageBinds = pImageBinds_;
+      return *this;
+    }
+
+    BindSparseInfo & setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
+    {
+      signalSemaphoreCount = signalSemaphoreCount_;
+      return *this;
+    }
+
+    BindSparseInfo & setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
+    {
+      pSignalSemaphores = pSignalSemaphores_;
+      return *this;
+    }
+
+    operator VkBindSparseInfo const&() const
+    {
+      return *reinterpret_cast<const VkBindSparseInfo*>( this );
+    }
+
+    operator VkBindSparseInfo &()
+    {
+      return *reinterpret_cast<VkBindSparseInfo*>( this );
+    }
+
+    bool operator==( BindSparseInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
+          && ( pWaitSemaphores == rhs.pWaitSemaphores )
+          && ( bufferBindCount == rhs.bufferBindCount )
+          && ( pBufferBinds == rhs.pBufferBinds )
+          && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount )
+          && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds )
+          && ( imageBindCount == rhs.imageBindCount )
+          && ( pImageBinds == rhs.pImageBinds )
+          && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
+          && ( pSignalSemaphores == rhs.pSignalSemaphores );
+    }
+
+    bool operator!=( BindSparseInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eBindSparseInfo;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t waitSemaphoreCount;
+    const Semaphore* pWaitSemaphores;
+    uint32_t bufferBindCount;
+    const SparseBufferMemoryBindInfo* pBufferBinds;
+    uint32_t imageOpaqueBindCount;
+    const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
+    uint32_t imageBindCount;
+    const SparseImageMemoryBindInfo* pImageBinds;
+    uint32_t signalSemaphoreCount;
+    const Semaphore* pSignalSemaphores;
+  };
+  static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" );
+
+  struct BufferCopy
+  {
+    BufferCopy( DeviceSize srcOffset_ = 0,
+                DeviceSize dstOffset_ = 0,
+                DeviceSize size_ = 0 )
+      : srcOffset( srcOffset_ )
+      , dstOffset( dstOffset_ )
+      , size( size_ )
+    {}
+
+    BufferCopy( VkBufferCopy const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BufferCopy ) );
+    }
+
+    BufferCopy& operator=( VkBufferCopy const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BufferCopy ) );
+      return *this;
+    }
+
+    BufferCopy & setSrcOffset( DeviceSize srcOffset_ )
+    {
+      srcOffset = srcOffset_;
+      return *this;
+    }
+
+    BufferCopy & setDstOffset( DeviceSize dstOffset_ )
+    {
+      dstOffset = dstOffset_;
+      return *this;
+    }
+
+    BufferCopy & setSize( DeviceSize size_ )
+    {
+      size = size_;
+      return *this;
+    }
+
+    operator VkBufferCopy const&() const
+    {
+      return *reinterpret_cast<const VkBufferCopy*>( this );
+    }
+
+    operator VkBufferCopy &()
+    {
+      return *reinterpret_cast<VkBufferCopy*>( this );
+    }
+
+    bool operator==( BufferCopy const& rhs ) const
+    {
+      return ( srcOffset == rhs.srcOffset )
+          && ( dstOffset == rhs.dstOffset )
+          && ( size == rhs.size );
+    }
+
+    bool operator!=( BufferCopy const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    DeviceSize srcOffset;
+    DeviceSize dstOffset;
+    DeviceSize size;
+  };
+  static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" );
+
+  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 )
+      : flags( flags_ )
+      , size( size_ )
+      , usage( usage_ )
+      , sharingMode( sharingMode_ )
+      , queueFamilyIndexCount( queueFamilyIndexCount_ )
+      , pQueueFamilyIndices( pQueueFamilyIndices_ )
+    {}
+
+    BufferCreateInfo( VkBufferCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
+    }
+
+    BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
+      return *this;
+    }
+
+    BufferCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    BufferCreateInfo & setFlags( BufferCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    BufferCreateInfo & setSize( DeviceSize size_ )
+    {
+      size = size_;
+      return *this;
+    }
+
+    BufferCreateInfo & setUsage( BufferUsageFlags usage_ )
+    {
+      usage = usage_;
+      return *this;
+    }
+
+    BufferCreateInfo & setSharingMode( SharingMode sharingMode_ )
+    {
+      sharingMode = sharingMode_;
+      return *this;
+    }
+
+    BufferCreateInfo & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+    {
+      queueFamilyIndexCount = queueFamilyIndexCount_;
+      return *this;
+    }
+
+    BufferCreateInfo & setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
+    {
+      pQueueFamilyIndices = pQueueFamilyIndices_;
+      return *this;
+    }
+
+    operator VkBufferCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkBufferCreateInfo*>( this );
+    }
+
+    operator VkBufferCreateInfo &()
+    {
+      return *reinterpret_cast<VkBufferCreateInfo*>( this );
+    }
+
+    bool operator==( BufferCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( size == rhs.size )
+          && ( usage == rhs.usage )
+          && ( sharingMode == rhs.sharingMode )
+          && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
+          && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
+    }
+
+    bool operator!=( BufferCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eBufferCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    BufferCreateFlags flags;
+    DeviceSize size;
+    BufferUsageFlags usage;
+    SharingMode sharingMode;
+    uint32_t queueFamilyIndexCount;
+    const uint32_t* pQueueFamilyIndices;
+  };
+  static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" );
+
+  struct ImageSubresourceLayers
+  {
+    ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
+                            uint32_t mipLevel_ = 0,
+                            uint32_t baseArrayLayer_ = 0,
+                            uint32_t layerCount_ = 0 )
+      : aspectMask( aspectMask_ )
+      , mipLevel( mipLevel_ )
+      , baseArrayLayer( baseArrayLayer_ )
+      , layerCount( layerCount_ )
+    {}
+
+    ImageSubresourceLayers( VkImageSubresourceLayers const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
+    }
+
+    ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
+      return *this;
+    }
+
+    ImageSubresourceLayers & setAspectMask( ImageAspectFlags aspectMask_ )
+    {
+      aspectMask = aspectMask_;
+      return *this;
+    }
+
+    ImageSubresourceLayers & setMipLevel( uint32_t mipLevel_ )
+    {
+      mipLevel = mipLevel_;
+      return *this;
+    }
+
+    ImageSubresourceLayers & setBaseArrayLayer( uint32_t baseArrayLayer_ )
+    {
+      baseArrayLayer = baseArrayLayer_;
+      return *this;
+    }
+
+    ImageSubresourceLayers & setLayerCount( uint32_t layerCount_ )
+    {
+      layerCount = layerCount_;
+      return *this;
+    }
+
+    operator VkImageSubresourceLayers const&() const
+    {
+      return *reinterpret_cast<const VkImageSubresourceLayers*>( this );
+    }
+
+    operator VkImageSubresourceLayers &()
+    {
+      return *reinterpret_cast<VkImageSubresourceLayers*>( this );
+    }
+
+    bool operator==( ImageSubresourceLayers const& rhs ) const
+    {
+      return ( aspectMask == rhs.aspectMask )
+          && ( mipLevel == rhs.mipLevel )
+          && ( baseArrayLayer == rhs.baseArrayLayer )
+          && ( layerCount == rhs.layerCount );
+    }
+
+    bool operator!=( ImageSubresourceLayers const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ImageAspectFlags aspectMask;
+    uint32_t mipLevel;
+    uint32_t baseArrayLayer;
+    uint32_t layerCount;
+  };
+  static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" );
+
+  struct BufferImageCopy
+  {
+    BufferImageCopy( DeviceSize bufferOffset_ = 0,
+                     uint32_t bufferRowLength_ = 0,
+                     uint32_t bufferImageHeight_ = 0,
+                     ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(),
+                     Offset3D imageOffset_ = Offset3D(),
+                     Extent3D imageExtent_ = Extent3D() )
+      : bufferOffset( bufferOffset_ )
+      , bufferRowLength( bufferRowLength_ )
+      , bufferImageHeight( bufferImageHeight_ )
+      , imageSubresource( imageSubresource_ )
+      , imageOffset( imageOffset_ )
+      , imageExtent( imageExtent_ )
+    {}
+
+    BufferImageCopy( VkBufferImageCopy const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BufferImageCopy ) );
+    }
+
+    BufferImageCopy& operator=( VkBufferImageCopy const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BufferImageCopy ) );
+      return *this;
+    }
+
+    BufferImageCopy & setBufferOffset( DeviceSize bufferOffset_ )
+    {
+      bufferOffset = bufferOffset_;
+      return *this;
+    }
+
+    BufferImageCopy & setBufferRowLength( uint32_t bufferRowLength_ )
+    {
+      bufferRowLength = bufferRowLength_;
+      return *this;
+    }
+
+    BufferImageCopy & setBufferImageHeight( uint32_t bufferImageHeight_ )
+    {
+      bufferImageHeight = bufferImageHeight_;
+      return *this;
+    }
+
+    BufferImageCopy & setImageSubresource( ImageSubresourceLayers imageSubresource_ )
+    {
+      imageSubresource = imageSubresource_;
+      return *this;
+    }
+
+    BufferImageCopy & setImageOffset( Offset3D imageOffset_ )
+    {
+      imageOffset = imageOffset_;
+      return *this;
+    }
+
+    BufferImageCopy & setImageExtent( Extent3D imageExtent_ )
+    {
+      imageExtent = imageExtent_;
+      return *this;
+    }
+
+    operator VkBufferImageCopy const&() const
+    {
+      return *reinterpret_cast<const VkBufferImageCopy*>( this );
+    }
+
+    operator VkBufferImageCopy &()
+    {
+      return *reinterpret_cast<VkBufferImageCopy*>( this );
+    }
+
+    bool operator==( BufferImageCopy const& rhs ) const
+    {
+      return ( bufferOffset == rhs.bufferOffset )
+          && ( bufferRowLength == rhs.bufferRowLength )
+          && ( bufferImageHeight == rhs.bufferImageHeight )
+          && ( imageSubresource == rhs.imageSubresource )
+          && ( imageOffset == rhs.imageOffset )
+          && ( imageExtent == rhs.imageExtent );
+    }
+
+    bool operator!=( BufferImageCopy const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    DeviceSize bufferOffset;
+    uint32_t bufferRowLength;
+    uint32_t bufferImageHeight;
+    ImageSubresourceLayers imageSubresource;
+    Offset3D imageOffset;
+    Extent3D imageExtent;
+  };
+  static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" );
+
+  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 )
+      : srcAccessMask( srcAccessMask_ )
+      , dstAccessMask( dstAccessMask_ )
+      , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
+      , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
+      , buffer( buffer_ )
+      , offset( offset_ )
+      , size( size_ )
+    {}
+
+    BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
+    }
+
+    BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
+      return *this;
+    }
+
+    BufferMemoryBarrier & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    BufferMemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ )
+    {
+      srcAccessMask = srcAccessMask_;
+      return *this;
+    }
+
+    BufferMemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ )
+    {
+      dstAccessMask = dstAccessMask_;
+      return *this;
+    }
+
+    BufferMemoryBarrier & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
+    {
+      srcQueueFamilyIndex = srcQueueFamilyIndex_;
+      return *this;
+    }
+
+    BufferMemoryBarrier & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
+    {
+      dstQueueFamilyIndex = dstQueueFamilyIndex_;
+      return *this;
+    }
+
+    BufferMemoryBarrier & setBuffer( Buffer buffer_ )
+    {
+      buffer = buffer_;
+      return *this;
+    }
+
+    BufferMemoryBarrier & setOffset( DeviceSize offset_ )
+    {
+      offset = offset_;
+      return *this;
+    }
+
+    BufferMemoryBarrier & setSize( DeviceSize size_ )
+    {
+      size = size_;
+      return *this;
+    }
+
+    operator VkBufferMemoryBarrier const&() const
+    {
+      return *reinterpret_cast<const VkBufferMemoryBarrier*>( this );
+    }
+
+    operator VkBufferMemoryBarrier &()
+    {
+      return *reinterpret_cast<VkBufferMemoryBarrier*>( this );
+    }
+
+    bool operator==( BufferMemoryBarrier const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( srcAccessMask == rhs.srcAccessMask )
+          && ( dstAccessMask == rhs.dstAccessMask )
+          && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
+          && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
+          && ( buffer == rhs.buffer )
+          && ( offset == rhs.offset )
+          && ( size == rhs.size );
+    }
+
+    bool operator!=( BufferMemoryBarrier const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eBufferMemoryBarrier;
+
+  public:
+    const void* pNext = nullptr;
+    AccessFlags srcAccessMask;
+    AccessFlags dstAccessMask;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    Buffer buffer;
+    DeviceSize offset;
+    DeviceSize size;
+  };
+  static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" );
+
+  struct BufferMemoryRequirementsInfo2
+  {
+    BufferMemoryRequirementsInfo2( Buffer buffer_ = Buffer() )
+      : buffer( buffer_ )
+    {}
+
+    BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2 ) );
+    }
+
+    BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2 ) );
+      return *this;
+    }
+
+    BufferMemoryRequirementsInfo2 & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    BufferMemoryRequirementsInfo2 & setBuffer( Buffer buffer_ )
+    {
+      buffer = buffer_;
+      return *this;
+    }
+
+    operator VkBufferMemoryRequirementsInfo2 const&() const
+    {
+      return *reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( this );
+    }
+
+    operator VkBufferMemoryRequirementsInfo2 &()
+    {
+      return *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>( this );
+    }
+
+    bool operator==( BufferMemoryRequirementsInfo2 const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( buffer == rhs.buffer );
+    }
+
+    bool operator!=( BufferMemoryRequirementsInfo2 const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eBufferMemoryRequirementsInfo2;
+
+  public:
+    const void* pNext = nullptr;
+    Buffer buffer;
+  };
+  static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
+
+  struct BufferViewCreateInfo
+  {
+    BufferViewCreateInfo( BufferViewCreateFlags flags_ = BufferViewCreateFlags(),
+                          Buffer buffer_ = Buffer(),
+                          Format format_ = Format::eUndefined,
+                          DeviceSize offset_ = 0,
+                          DeviceSize range_ = 0 )
+      : flags( flags_ )
+      , buffer( buffer_ )
+      , format( format_ )
+      , offset( offset_ )
+      , range( range_ )
+    {}
+
+    BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) );
+    }
+
+    BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) );
+      return *this;
+    }
+
+    BufferViewCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    BufferViewCreateInfo & setFlags( BufferViewCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    BufferViewCreateInfo & setBuffer( Buffer buffer_ )
+    {
+      buffer = buffer_;
+      return *this;
+    }
+
+    BufferViewCreateInfo & setFormat( Format format_ )
+    {
+      format = format_;
+      return *this;
+    }
+
+    BufferViewCreateInfo & setOffset( DeviceSize offset_ )
+    {
+      offset = offset_;
+      return *this;
+    }
+
+    BufferViewCreateInfo & setRange( DeviceSize range_ )
+    {
+      range = range_;
+      return *this;
+    }
+
+    operator VkBufferViewCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkBufferViewCreateInfo*>( this );
+    }
+
+    operator VkBufferViewCreateInfo &()
+    {
+      return *reinterpret_cast<VkBufferViewCreateInfo*>( this );
+    }
+
+    bool operator==( BufferViewCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( buffer == rhs.buffer )
+          && ( format == rhs.format )
+          && ( offset == rhs.offset )
+          && ( range == rhs.range );
+    }
+
+    bool operator!=( BufferViewCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eBufferViewCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    BufferViewCreateFlags flags;
+    Buffer buffer;
+    Format format;
+    DeviceSize offset;
+    DeviceSize range;
+  };
+  static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" );
+
+  struct CalibratedTimestampInfoEXT
+  {
+    CalibratedTimestampInfoEXT( TimeDomainEXT timeDomain_ = TimeDomainEXT::eDevice )
+      : timeDomain( timeDomain_ )
+    {}
+
+    CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CalibratedTimestampInfoEXT ) );
+    }
+
+    CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CalibratedTimestampInfoEXT ) );
+      return *this;
+    }
+
+    CalibratedTimestampInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    CalibratedTimestampInfoEXT & setTimeDomain( TimeDomainEXT timeDomain_ )
+    {
+      timeDomain = timeDomain_;
+      return *this;
+    }
+
+    operator VkCalibratedTimestampInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkCalibratedTimestampInfoEXT*>( this );
+    }
+
+    operator VkCalibratedTimestampInfoEXT &()
+    {
+      return *reinterpret_cast<VkCalibratedTimestampInfoEXT*>( this );
+    }
+
+    bool operator==( CalibratedTimestampInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( timeDomain == rhs.timeDomain );
+    }
+
+    bool operator!=( CalibratedTimestampInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eCalibratedTimestampInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    TimeDomainEXT timeDomain;
+  };
+  static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "struct and wrapper have different size!" );
+
+  struct CheckpointDataNV
+  {
+    operator VkCheckpointDataNV const&() const
+    {
+      return *reinterpret_cast<const VkCheckpointDataNV*>( this );
+    }
+
+    operator VkCheckpointDataNV &()
+    {
+      return *reinterpret_cast<VkCheckpointDataNV*>( this );
+    }
+
+    bool operator==( CheckpointDataNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( stage == rhs.stage )
+          && ( pCheckpointMarker == rhs.pCheckpointMarker );
+    }
+
+    bool operator!=( CheckpointDataNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eCheckpointDataNV;
+
+  public:
+    void* pNext = nullptr;
+    PipelineStageFlagBits stage;
+    void* pCheckpointMarker;
+  };
+  static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "struct and wrapper have different size!" );
+
+  union ClearColorValue
+  {
+    ClearColorValue( const std::array<float,4>& float32_ = { { 0 } } )
+    {
+      memcpy( float32, float32_.data(), 4 * sizeof( float ) );
+    }
+
+    ClearColorValue( const std::array<int32_t,4>& int32_ )
+    {
+      memcpy( int32, int32_.data(), 4 * sizeof( int32_t ) );
+    }
+
+    ClearColorValue( const std::array<uint32_t,4>& uint32_ )
+    {
+      memcpy( uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
+    }
+
+
+    ClearColorValue & setFloat32( std::array<float,4> float32_ )
+    {
+      memcpy( float32, float32_.data(), 4 * sizeof( float ) );
+      return *this;
+    }
+
+    ClearColorValue & setInt32( std::array<int32_t,4> int32_ )
+    {
+      memcpy( int32, int32_.data(), 4 * sizeof( int32_t ) );
+      return *this;
+    }
+
+    ClearColorValue & setUint32( std::array<uint32_t,4> uint32_ )
+    {
+      memcpy( uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
+      return *this;
+    }
+    operator VkClearColorValue const&() const
+    {
+      return *reinterpret_cast<const VkClearColorValue*>(this);
+    }
+
+    operator VkClearColorValue &()
+    {
+      return *reinterpret_cast<VkClearColorValue*>(this);
+    }
+
+    float float32[4];
+    int32_t int32[4];
+    uint32_t uint32[4];
+  };
+
+  struct ClearDepthStencilValue
+  {
+    ClearDepthStencilValue( float depth_ = 0,
+                            uint32_t stencil_ = 0 )
+      : depth( depth_ )
+      , stencil( stencil_ )
+    {}
+
+    ClearDepthStencilValue( VkClearDepthStencilValue const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
+    }
+
+    ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
+      return *this;
+    }
+
+    ClearDepthStencilValue & setDepth( float depth_ )
+    {
+      depth = depth_;
+      return *this;
+    }
+
+    ClearDepthStencilValue & setStencil( uint32_t stencil_ )
+    {
+      stencil = stencil_;
+      return *this;
+    }
+
+    operator VkClearDepthStencilValue const&() const
+    {
+      return *reinterpret_cast<const VkClearDepthStencilValue*>( this );
+    }
+
+    operator VkClearDepthStencilValue &()
+    {
+      return *reinterpret_cast<VkClearDepthStencilValue*>( this );
+    }
+
+    bool operator==( ClearDepthStencilValue const& rhs ) const
+    {
+      return ( depth == rhs.depth )
+          && ( stencil == rhs.stencil );
+    }
+
+    bool operator!=( ClearDepthStencilValue const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    float depth;
+    uint32_t stencil;
+  };
+  static_assert( sizeof( ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), "struct and wrapper have different size!" );
+
+  union ClearValue
+  {
+    ClearValue( ClearColorValue color_ = ClearColorValue() )
+    {
+      color = color_;
+    }
+
+    ClearValue( ClearDepthStencilValue depthStencil_ )
+    {
+      depthStencil = depthStencil_;
+    }
+
+
+    ClearValue & setColor( ClearColorValue color_ )
+    {
+      color = color_;
+      return *this;
+    }
+
+    ClearValue & setDepthStencil( ClearDepthStencilValue depthStencil_ )
+    {
+      depthStencil = depthStencil_;
+      return *this;
+    }
+    operator VkClearValue const&() const
+    {
+      return *reinterpret_cast<const VkClearValue*>(this);
+    }
+
+    operator VkClearValue &()
+    {
+      return *reinterpret_cast<VkClearValue*>(this);
+    }
+
+#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+    ClearColorValue color;
+    ClearDepthStencilValue depthStencil;
+#else
+    VkClearColorValue color;
+    VkClearDepthStencilValue depthStencil;
+#endif  /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
+  };
+
+  struct ClearAttachment
+  {
+    ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
+                     uint32_t colorAttachment_ = 0,
+                     ClearValue clearValue_ = ClearValue() )
+      : aspectMask( aspectMask_ )
+      , colorAttachment( colorAttachment_ )
+      , clearValue( clearValue_ )
+    {}
+
+    ClearAttachment( VkClearAttachment const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ClearAttachment ) );
+    }
+
+    ClearAttachment& operator=( VkClearAttachment const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ClearAttachment ) );
+      return *this;
+    }
+
+    ClearAttachment & setAspectMask( ImageAspectFlags aspectMask_ )
+    {
+      aspectMask = aspectMask_;
+      return *this;
+    }
+
+    ClearAttachment & setColorAttachment( uint32_t colorAttachment_ )
+    {
+      colorAttachment = colorAttachment_;
+      return *this;
+    }
+
+    ClearAttachment & setClearValue( ClearValue clearValue_ )
+    {
+      clearValue = clearValue_;
+      return *this;
+    }
+
+    operator VkClearAttachment const&() const
+    {
+      return *reinterpret_cast<const VkClearAttachment*>( this );
+    }
+
+    operator VkClearAttachment &()
+    {
+      return *reinterpret_cast<VkClearAttachment*>( this );
+    }
+
+    ImageAspectFlags aspectMask;
+    uint32_t colorAttachment;
+    ClearValue clearValue;
+  };
+  static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" );
+
+  struct ClearRect
+  {
+    ClearRect( Rect2D rect_ = Rect2D(),
+               uint32_t baseArrayLayer_ = 0,
+               uint32_t layerCount_ = 0 )
+      : rect( rect_ )
+      , baseArrayLayer( baseArrayLayer_ )
+      , layerCount( layerCount_ )
+    {}
+
+    ClearRect( VkClearRect const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ClearRect ) );
+    }
+
+    ClearRect& operator=( VkClearRect const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ClearRect ) );
+      return *this;
+    }
+
+    ClearRect & setRect( Rect2D rect_ )
+    {
+      rect = rect_;
+      return *this;
+    }
+
+    ClearRect & setBaseArrayLayer( uint32_t baseArrayLayer_ )
+    {
+      baseArrayLayer = baseArrayLayer_;
+      return *this;
+    }
+
+    ClearRect & setLayerCount( uint32_t layerCount_ )
+    {
+      layerCount = layerCount_;
+      return *this;
+    }
+
+    operator VkClearRect const&() const
+    {
+      return *reinterpret_cast<const VkClearRect*>( this );
+    }
+
+    operator VkClearRect &()
+    {
+      return *reinterpret_cast<VkClearRect*>( this );
+    }
+
+    bool operator==( ClearRect const& rhs ) const
+    {
+      return ( rect == rhs.rect )
+          && ( baseArrayLayer == rhs.baseArrayLayer )
+          && ( layerCount == rhs.layerCount );
+    }
+
+    bool operator!=( ClearRect const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    Rect2D rect;
+    uint32_t baseArrayLayer;
+    uint32_t layerCount;
+  };
+  static_assert( sizeof( ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" );
+
+  struct IndirectCommandsTokenNVX
+  {
+    IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline,
+                              Buffer buffer_ = Buffer(),
+                              DeviceSize offset_ = 0 )
+      : tokenType( tokenType_ )
+      , buffer( buffer_ )
+      , offset( offset_ )
+    {}
+
+    IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
+    }
+
+    IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
+      return *this;
+    }
+
+    IndirectCommandsTokenNVX & setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
+    {
+      tokenType = tokenType_;
+      return *this;
+    }
+
+    IndirectCommandsTokenNVX & setBuffer( Buffer buffer_ )
+    {
+      buffer = buffer_;
+      return *this;
+    }
+
+    IndirectCommandsTokenNVX & setOffset( DeviceSize offset_ )
+    {
+      offset = offset_;
+      return *this;
+    }
+
+    operator VkIndirectCommandsTokenNVX const&() const
+    {
+      return *reinterpret_cast<const VkIndirectCommandsTokenNVX*>( this );
+    }
+
+    operator VkIndirectCommandsTokenNVX &()
+    {
+      return *reinterpret_cast<VkIndirectCommandsTokenNVX*>( this );
+    }
+
+    bool operator==( IndirectCommandsTokenNVX const& rhs ) const
+    {
+      return ( tokenType == rhs.tokenType )
+          && ( buffer == rhs.buffer )
+          && ( offset == rhs.offset );
+    }
+
+    bool operator!=( IndirectCommandsTokenNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    IndirectCommandsTokenTypeNVX tokenType;
+    Buffer buffer;
+    DeviceSize offset;
+  };
+  static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" );
+
+  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 )
+      : objectTable( objectTable_ )
+      , indirectCommandsLayout( indirectCommandsLayout_ )
+      , indirectCommandsTokenCount( indirectCommandsTokenCount_ )
+      , pIndirectCommandsTokens( pIndirectCommandsTokens_ )
+      , maxSequencesCount( maxSequencesCount_ )
+      , targetCommandBuffer( targetCommandBuffer_ )
+      , sequencesCountBuffer( sequencesCountBuffer_ )
+      , sequencesCountOffset( sequencesCountOffset_ )
+      , sequencesIndexBuffer( sequencesIndexBuffer_ )
+      , sequencesIndexOffset( sequencesIndexOffset_ )
+    {}
+
+    CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) );
+    }
+
+    CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) );
+      return *this;
+    }
+
+    CmdProcessCommandsInfoNVX & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    CmdProcessCommandsInfoNVX & setObjectTable( ObjectTableNVX objectTable_ )
+    {
+      objectTable = objectTable_;
+      return *this;
+    }
+
+    CmdProcessCommandsInfoNVX & setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ )
+    {
+      indirectCommandsLayout = indirectCommandsLayout_;
+      return *this;
+    }
+
+    CmdProcessCommandsInfoNVX & setIndirectCommandsTokenCount( uint32_t indirectCommandsTokenCount_ )
+    {
+      indirectCommandsTokenCount = indirectCommandsTokenCount_;
+      return *this;
+    }
+
+    CmdProcessCommandsInfoNVX & setPIndirectCommandsTokens( const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ )
+    {
+      pIndirectCommandsTokens = pIndirectCommandsTokens_;
+      return *this;
+    }
+
+    CmdProcessCommandsInfoNVX & setMaxSequencesCount( uint32_t maxSequencesCount_ )
+    {
+      maxSequencesCount = maxSequencesCount_;
+      return *this;
+    }
+
+    CmdProcessCommandsInfoNVX & setTargetCommandBuffer( CommandBuffer targetCommandBuffer_ )
+    {
+      targetCommandBuffer = targetCommandBuffer_;
+      return *this;
+    }
+
+    CmdProcessCommandsInfoNVX & setSequencesCountBuffer( Buffer sequencesCountBuffer_ )
+    {
+      sequencesCountBuffer = sequencesCountBuffer_;
+      return *this;
+    }
+
+    CmdProcessCommandsInfoNVX & setSequencesCountOffset( DeviceSize sequencesCountOffset_ )
+    {
+      sequencesCountOffset = sequencesCountOffset_;
+      return *this;
+    }
+
+    CmdProcessCommandsInfoNVX & setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ )
+    {
+      sequencesIndexBuffer = sequencesIndexBuffer_;
+      return *this;
+    }
+
+    CmdProcessCommandsInfoNVX & setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ )
+    {
+      sequencesIndexOffset = sequencesIndexOffset_;
+      return *this;
+    }
+
+    operator VkCmdProcessCommandsInfoNVX const&() const
+    {
+      return *reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>( this );
+    }
+
+    operator VkCmdProcessCommandsInfoNVX &()
+    {
+      return *reinterpret_cast<VkCmdProcessCommandsInfoNVX*>( this );
+    }
+
+    bool operator==( CmdProcessCommandsInfoNVX const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( objectTable == rhs.objectTable )
+          && ( indirectCommandsLayout == rhs.indirectCommandsLayout )
+          && ( indirectCommandsTokenCount == rhs.indirectCommandsTokenCount )
+          && ( pIndirectCommandsTokens == rhs.pIndirectCommandsTokens )
+          && ( maxSequencesCount == rhs.maxSequencesCount )
+          && ( targetCommandBuffer == rhs.targetCommandBuffer )
+          && ( sequencesCountBuffer == rhs.sequencesCountBuffer )
+          && ( sequencesCountOffset == rhs.sequencesCountOffset )
+          && ( sequencesIndexBuffer == rhs.sequencesIndexBuffer )
+          && ( sequencesIndexOffset == rhs.sequencesIndexOffset );
+    }
+
+    bool operator!=( CmdProcessCommandsInfoNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eCmdProcessCommandsInfoNVX;
+
+  public:
+    const void* pNext = nullptr;
+    ObjectTableNVX objectTable;
+    IndirectCommandsLayoutNVX indirectCommandsLayout;
+    uint32_t indirectCommandsTokenCount;
+    const IndirectCommandsTokenNVX* pIndirectCommandsTokens;
+    uint32_t maxSequencesCount;
+    CommandBuffer targetCommandBuffer;
+    Buffer sequencesCountBuffer;
+    DeviceSize sequencesCountOffset;
+    Buffer sequencesIndexBuffer;
+    DeviceSize sequencesIndexOffset;
+  };
+  static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "struct and wrapper have different size!" );
+
+  struct CmdReserveSpaceForCommandsInfoNVX
+  {
+    CmdReserveSpaceForCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(),
+                                       IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(),
+                                       uint32_t maxSequencesCount_ = 0 )
+      : objectTable( objectTable_ )
+      , indirectCommandsLayout( indirectCommandsLayout_ )
+      , maxSequencesCount( maxSequencesCount_ )
+    {}
+
+    CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) );
+    }
+
+    CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) );
+      return *this;
+    }
+
+    CmdReserveSpaceForCommandsInfoNVX & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    CmdReserveSpaceForCommandsInfoNVX & setObjectTable( ObjectTableNVX objectTable_ )
+    {
+      objectTable = objectTable_;
+      return *this;
+    }
+
+    CmdReserveSpaceForCommandsInfoNVX & setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ )
+    {
+      indirectCommandsLayout = indirectCommandsLayout_;
+      return *this;
+    }
+
+    CmdReserveSpaceForCommandsInfoNVX & setMaxSequencesCount( uint32_t maxSequencesCount_ )
+    {
+      maxSequencesCount = maxSequencesCount_;
+      return *this;
+    }
+
+    operator VkCmdReserveSpaceForCommandsInfoNVX const&() const
+    {
+      return *reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( this );
+    }
+
+    operator VkCmdReserveSpaceForCommandsInfoNVX &()
+    {
+      return *reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX*>( this );
+    }
+
+    bool operator==( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( objectTable == rhs.objectTable )
+          && ( indirectCommandsLayout == rhs.indirectCommandsLayout )
+          && ( maxSequencesCount == rhs.maxSequencesCount );
+    }
+
+    bool operator!=( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX;
+
+  public:
+    const void* pNext = nullptr;
+    ObjectTableNVX objectTable;
+    IndirectCommandsLayoutNVX indirectCommandsLayout;
+    uint32_t maxSequencesCount;
+  };
+  static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "struct and wrapper have different size!" );
+
+  struct CoarseSampleLocationNV
+  {
+    CoarseSampleLocationNV( uint32_t pixelX_ = 0,
+                            uint32_t pixelY_ = 0,
+                            uint32_t sample_ = 0 )
+      : pixelX( pixelX_ )
+      , pixelY( pixelY_ )
+      , sample( sample_ )
+    {}
+
+    CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
+    }
+
+    CoarseSampleLocationNV& operator=( VkCoarseSampleLocationNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
+      return *this;
+    }
+
+    CoarseSampleLocationNV & setPixelX( uint32_t pixelX_ )
+    {
+      pixelX = pixelX_;
+      return *this;
+    }
+
+    CoarseSampleLocationNV & setPixelY( uint32_t pixelY_ )
+    {
+      pixelY = pixelY_;
+      return *this;
+    }
+
+    CoarseSampleLocationNV & setSample( uint32_t sample_ )
+    {
+      sample = sample_;
+      return *this;
+    }
+
+    operator VkCoarseSampleLocationNV const&() const
+    {
+      return *reinterpret_cast<const VkCoarseSampleLocationNV*>( this );
+    }
+
+    operator VkCoarseSampleLocationNV &()
+    {
+      return *reinterpret_cast<VkCoarseSampleLocationNV*>( this );
+    }
+
+    bool operator==( CoarseSampleLocationNV const& rhs ) const
+    {
+      return ( pixelX == rhs.pixelX )
+          && ( pixelY == rhs.pixelY )
+          && ( sample == rhs.sample );
+    }
+
+    bool operator!=( CoarseSampleLocationNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t pixelX;
+    uint32_t pixelY;
+    uint32_t sample;
+  };
+  static_assert( sizeof( CoarseSampleLocationNV ) == sizeof( VkCoarseSampleLocationNV ), "struct and wrapper have different size!" );
+
+  struct CoarseSampleOrderCustomNV
+  {
+    CoarseSampleOrderCustomNV( ShadingRatePaletteEntryNV shadingRate_ = ShadingRatePaletteEntryNV::eNoInvocations,
+                               uint32_t sampleCount_ = 0,
+                               uint32_t sampleLocationCount_ = 0,
+                               const CoarseSampleLocationNV* pSampleLocations_ = nullptr )
+      : shadingRate( shadingRate_ )
+      , sampleCount( sampleCount_ )
+      , sampleLocationCount( sampleLocationCount_ )
+      , pSampleLocations( pSampleLocations_ )
+    {}
+
+    CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) );
+    }
+
+    CoarseSampleOrderCustomNV& operator=( VkCoarseSampleOrderCustomNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) );
+      return *this;
+    }
+
+    CoarseSampleOrderCustomNV & setShadingRate( ShadingRatePaletteEntryNV shadingRate_ )
+    {
+      shadingRate = shadingRate_;
+      return *this;
+    }
+
+    CoarseSampleOrderCustomNV & setSampleCount( uint32_t sampleCount_ )
+    {
+      sampleCount = sampleCount_;
+      return *this;
+    }
+
+    CoarseSampleOrderCustomNV & setSampleLocationCount( uint32_t sampleLocationCount_ )
+    {
+      sampleLocationCount = sampleLocationCount_;
+      return *this;
+    }
+
+    CoarseSampleOrderCustomNV & setPSampleLocations( const CoarseSampleLocationNV* pSampleLocations_ )
+    {
+      pSampleLocations = pSampleLocations_;
+      return *this;
+    }
+
+    operator VkCoarseSampleOrderCustomNV const&() const
+    {
+      return *reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( this );
+    }
+
+    operator VkCoarseSampleOrderCustomNV &()
+    {
+      return *reinterpret_cast<VkCoarseSampleOrderCustomNV*>( this );
+    }
+
+    bool operator==( CoarseSampleOrderCustomNV const& rhs ) const
+    {
+      return ( shadingRate == rhs.shadingRate )
+          && ( sampleCount == rhs.sampleCount )
+          && ( sampleLocationCount == rhs.sampleLocationCount )
+          && ( pSampleLocations == rhs.pSampleLocations );
+    }
+
+    bool operator!=( CoarseSampleOrderCustomNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ShadingRatePaletteEntryNV shadingRate;
+    uint32_t sampleCount;
+    uint32_t sampleLocationCount;
+    const CoarseSampleLocationNV* pSampleLocations;
+  };
+  static_assert( sizeof( CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), "struct and wrapper have different size!" );
+
+  struct CommandBufferAllocateInfo
+  {
+    CommandBufferAllocateInfo( CommandPool commandPool_ = CommandPool(),
+                               CommandBufferLevel level_ = CommandBufferLevel::ePrimary,
+                               uint32_t commandBufferCount_ = 0 )
+      : commandPool( commandPool_ )
+      , level( level_ )
+      , commandBufferCount( commandBufferCount_ )
+    {}
+
+    CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) );
+    }
+
+    CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) );
+      return *this;
+    }
+
+    CommandBufferAllocateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    CommandBufferAllocateInfo & setCommandPool( CommandPool commandPool_ )
+    {
+      commandPool = commandPool_;
+      return *this;
+    }
+
+    CommandBufferAllocateInfo & setLevel( CommandBufferLevel level_ )
+    {
+      level = level_;
+      return *this;
+    }
+
+    CommandBufferAllocateInfo & setCommandBufferCount( uint32_t commandBufferCount_ )
+    {
+      commandBufferCount = commandBufferCount_;
+      return *this;
+    }
+
+    operator VkCommandBufferAllocateInfo const&() const
+    {
+      return *reinterpret_cast<const VkCommandBufferAllocateInfo*>( this );
+    }
+
+    operator VkCommandBufferAllocateInfo &()
+    {
+      return *reinterpret_cast<VkCommandBufferAllocateInfo*>( this );
+    }
+
+    bool operator==( CommandBufferAllocateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( commandPool == rhs.commandPool )
+          && ( level == rhs.level )
+          && ( commandBufferCount == rhs.commandBufferCount );
+    }
+
+    bool operator!=( CommandBufferAllocateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eCommandBufferAllocateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    CommandPool commandPool;
+    CommandBufferLevel level;
+    uint32_t commandBufferCount;
+  };
+  static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" );
+
+  struct CommandBufferInheritanceInfo
+  {
+    CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(),
+                                  uint32_t subpass_ = 0,
+                                  Framebuffer framebuffer_ = Framebuffer(),
+                                  Bool32 occlusionQueryEnable_ = 0,
+                                  QueryControlFlags queryFlags_ = QueryControlFlags(),
+                                  QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
+      : renderPass( renderPass_ )
+      , subpass( subpass_ )
+      , framebuffer( framebuffer_ )
+      , occlusionQueryEnable( occlusionQueryEnable_ )
+      , queryFlags( queryFlags_ )
+      , pipelineStatistics( pipelineStatistics_ )
+    {}
+
+    CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
+    }
+
+    CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
+      return *this;
+    }
+
+    CommandBufferInheritanceInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    CommandBufferInheritanceInfo & setRenderPass( RenderPass renderPass_ )
+    {
+      renderPass = renderPass_;
+      return *this;
+    }
+
+    CommandBufferInheritanceInfo & setSubpass( uint32_t subpass_ )
+    {
+      subpass = subpass_;
+      return *this;
+    }
+
+    CommandBufferInheritanceInfo & setFramebuffer( Framebuffer framebuffer_ )
+    {
+      framebuffer = framebuffer_;
+      return *this;
+    }
+
+    CommandBufferInheritanceInfo & setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ )
+    {
+      occlusionQueryEnable = occlusionQueryEnable_;
+      return *this;
+    }
+
+    CommandBufferInheritanceInfo & setQueryFlags( QueryControlFlags queryFlags_ )
+    {
+      queryFlags = queryFlags_;
+      return *this;
+    }
+
+    CommandBufferInheritanceInfo & setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
+    {
+      pipelineStatistics = pipelineStatistics_;
+      return *this;
+    }
+
+    operator VkCommandBufferInheritanceInfo const&() const
+    {
+      return *reinterpret_cast<const VkCommandBufferInheritanceInfo*>( this );
+    }
+
+    operator VkCommandBufferInheritanceInfo &()
+    {
+      return *reinterpret_cast<VkCommandBufferInheritanceInfo*>( this );
+    }
+
+    bool operator==( CommandBufferInheritanceInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( renderPass == rhs.renderPass )
+          && ( subpass == rhs.subpass )
+          && ( framebuffer == rhs.framebuffer )
+          && ( occlusionQueryEnable == rhs.occlusionQueryEnable )
+          && ( queryFlags == rhs.queryFlags )
+          && ( pipelineStatistics == rhs.pipelineStatistics );
+    }
+
+    bool operator!=( CommandBufferInheritanceInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eCommandBufferInheritanceInfo;
+
+  public:
+    const void* pNext = nullptr;
+    RenderPass renderPass;
+    uint32_t subpass;
+    Framebuffer framebuffer;
+    Bool32 occlusionQueryEnable;
+    QueryControlFlags queryFlags;
+    QueryPipelineStatisticFlags pipelineStatistics;
+  };
+  static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" );
+
+  struct CommandBufferBeginInfo
+  {
+    CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(),
+                            const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
+      : flags( flags_ )
+      , pInheritanceInfo( pInheritanceInfo_ )
+    {}
+
+    CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
+    }
+
+    CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
+      return *this;
+    }
+
+    CommandBufferBeginInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    CommandBufferBeginInfo & setFlags( CommandBufferUsageFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    CommandBufferBeginInfo & setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ )
+    {
+      pInheritanceInfo = pInheritanceInfo_;
+      return *this;
+    }
+
+    operator VkCommandBufferBeginInfo const&() const
+    {
+      return *reinterpret_cast<const VkCommandBufferBeginInfo*>( this );
+    }
+
+    operator VkCommandBufferBeginInfo &()
+    {
+      return *reinterpret_cast<VkCommandBufferBeginInfo*>( this );
+    }
+
+    bool operator==( CommandBufferBeginInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( pInheritanceInfo == rhs.pInheritanceInfo );
+    }
+
+    bool operator!=( CommandBufferBeginInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eCommandBufferBeginInfo;
+
+  public:
+    const void* pNext = nullptr;
+    CommandBufferUsageFlags flags;
+    const CommandBufferInheritanceInfo* pInheritanceInfo;
+  };
+  static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" );
+
+  struct CommandBufferInheritanceConditionalRenderingInfoEXT
+  {
+    CommandBufferInheritanceConditionalRenderingInfoEXT( Bool32 conditionalRenderingEnable_ = 0 )
+      : conditionalRenderingEnable( conditionalRenderingEnable_ )
+    {}
+
+    CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) );
+    }
+
+    CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) );
+      return *this;
+    }
+
+    CommandBufferInheritanceConditionalRenderingInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    CommandBufferInheritanceConditionalRenderingInfoEXT & setConditionalRenderingEnable( Bool32 conditionalRenderingEnable_ )
+    {
+      conditionalRenderingEnable = conditionalRenderingEnable_;
+      return *this;
+    }
+
+    operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>( this );
+    }
+
+    operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &()
+    {
+      return *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>( this );
+    }
+
+    bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( conditionalRenderingEnable == rhs.conditionalRenderingEnable );
+    }
+
+    bool operator!=( CommandBufferInheritanceConditionalRenderingInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    Bool32 conditionalRenderingEnable;
+  };
+  static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "struct and wrapper have different size!" );
+
+  struct CommandPoolCreateInfo
+  {
+    CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(),
+                           uint32_t queueFamilyIndex_ = 0 )
+      : flags( flags_ )
+      , queueFamilyIndex( queueFamilyIndex_ )
+    {}
+
+    CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
+    }
+
+    CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
+      return *this;
+    }
+
+    CommandPoolCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    CommandPoolCreateInfo & setFlags( CommandPoolCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    CommandPoolCreateInfo & setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
+    {
+      queueFamilyIndex = queueFamilyIndex_;
+      return *this;
+    }
+
+    operator VkCommandPoolCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkCommandPoolCreateInfo*>( this );
+    }
+
+    operator VkCommandPoolCreateInfo &()
+    {
+      return *reinterpret_cast<VkCommandPoolCreateInfo*>( this );
+    }
+
+    bool operator==( CommandPoolCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( queueFamilyIndex == rhs.queueFamilyIndex );
+    }
+
+    bool operator!=( CommandPoolCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eCommandPoolCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    CommandPoolCreateFlags flags;
+    uint32_t queueFamilyIndex;
+  };
+  static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" );
+
+  struct SpecializationMapEntry
+  {
+    SpecializationMapEntry( uint32_t constantID_ = 0,
+                            uint32_t offset_ = 0,
+                            size_t size_ = 0 )
+      : constantID( constantID_ )
+      , offset( offset_ )
+      , size( size_ )
+    {}
+
+    SpecializationMapEntry( VkSpecializationMapEntry const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
+    }
+
+    SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
+      return *this;
+    }
+
+    SpecializationMapEntry & setConstantID( uint32_t constantID_ )
+    {
+      constantID = constantID_;
+      return *this;
+    }
+
+    SpecializationMapEntry & setOffset( uint32_t offset_ )
+    {
+      offset = offset_;
+      return *this;
+    }
+
+    SpecializationMapEntry & setSize( size_t size_ )
+    {
+      size = size_;
+      return *this;
+    }
+
+    operator VkSpecializationMapEntry const&() const
+    {
+      return *reinterpret_cast<const VkSpecializationMapEntry*>( this );
+    }
+
+    operator VkSpecializationMapEntry &()
+    {
+      return *reinterpret_cast<VkSpecializationMapEntry*>( this );
+    }
+
+    bool operator==( SpecializationMapEntry const& rhs ) const
+    {
+      return ( constantID == rhs.constantID )
+          && ( offset == rhs.offset )
+          && ( size == rhs.size );
+    }
+
+    bool operator!=( SpecializationMapEntry const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t constantID;
+    uint32_t offset;
+    size_t size;
+  };
+  static_assert( sizeof( SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), "struct and wrapper have different size!" );
+
+  struct SpecializationInfo
+  {
+    SpecializationInfo( uint32_t mapEntryCount_ = 0,
+                        const SpecializationMapEntry* pMapEntries_ = nullptr,
+                        size_t dataSize_ = 0,
+                        const void* pData_ = nullptr )
+      : mapEntryCount( mapEntryCount_ )
+      , pMapEntries( pMapEntries_ )
+      , dataSize( dataSize_ )
+      , pData( pData_ )
+    {}
+
+    SpecializationInfo( VkSpecializationInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SpecializationInfo ) );
+    }
+
+    SpecializationInfo& operator=( VkSpecializationInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SpecializationInfo ) );
+      return *this;
+    }
+
+    SpecializationInfo & setMapEntryCount( uint32_t mapEntryCount_ )
+    {
+      mapEntryCount = mapEntryCount_;
+      return *this;
+    }
+
+    SpecializationInfo & setPMapEntries( const SpecializationMapEntry* pMapEntries_ )
+    {
+      pMapEntries = pMapEntries_;
+      return *this;
+    }
+
+    SpecializationInfo & setDataSize( size_t dataSize_ )
+    {
+      dataSize = dataSize_;
+      return *this;
+    }
+
+    SpecializationInfo & setPData( const void* pData_ )
+    {
+      pData = pData_;
+      return *this;
+    }
+
+    operator VkSpecializationInfo const&() const
+    {
+      return *reinterpret_cast<const VkSpecializationInfo*>( this );
+    }
+
+    operator VkSpecializationInfo &()
+    {
+      return *reinterpret_cast<VkSpecializationInfo*>( this );
+    }
+
+    bool operator==( SpecializationInfo const& rhs ) const
+    {
+      return ( mapEntryCount == rhs.mapEntryCount )
+          && ( pMapEntries == rhs.pMapEntries )
+          && ( dataSize == rhs.dataSize )
+          && ( pData == rhs.pData );
+    }
+
+    bool operator!=( SpecializationInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t mapEntryCount;
+    const SpecializationMapEntry* pMapEntries;
+    size_t dataSize;
+    const void* pData;
+  };
+  static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" );
+
+  struct PipelineShaderStageCreateInfo
+  {
+    PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(),
+                                   ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex,
+                                   ShaderModule module_ = ShaderModule(),
+                                   const char* pName_ = nullptr,
+                                   const SpecializationInfo* pSpecializationInfo_ = nullptr )
+      : flags( flags_ )
+      , stage( stage_ )
+      , module( module_ )
+      , pName( pName_ )
+      , pSpecializationInfo( pSpecializationInfo_ )
+    {}
+
+    PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
+    }
+
+    PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
+      return *this;
+    }
+
+    PipelineShaderStageCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineShaderStageCreateInfo & setFlags( PipelineShaderStageCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    PipelineShaderStageCreateInfo & setStage( ShaderStageFlagBits stage_ )
+    {
+      stage = stage_;
+      return *this;
+    }
+
+    PipelineShaderStageCreateInfo & setModule( ShaderModule module_ )
+    {
+      module = module_;
+      return *this;
+    }
+
+    PipelineShaderStageCreateInfo & setPName( const char* pName_ )
+    {
+      pName = pName_;
+      return *this;
+    }
+
+    PipelineShaderStageCreateInfo & setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ )
+    {
+      pSpecializationInfo = pSpecializationInfo_;
+      return *this;
+    }
+
+    operator VkPipelineShaderStageCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>( this );
+    }
+
+    operator VkPipelineShaderStageCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineShaderStageCreateInfo*>( this );
+    }
+
+    bool operator==( PipelineShaderStageCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( stage == rhs.stage )
+          && ( module == rhs.module )
+          && ( pName == rhs.pName )
+          && ( pSpecializationInfo == rhs.pSpecializationInfo );
+    }
+
+    bool operator!=( PipelineShaderStageCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineShaderStageCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    PipelineShaderStageCreateFlags flags;
+    ShaderStageFlagBits stage;
+    ShaderModule module;
+    const char* pName;
+    const SpecializationInfo* pSpecializationInfo;
+  };
+  static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" );
+
+  struct ComputePipelineCreateInfo
+  {
+    ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(),
+                               PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(),
+                               PipelineLayout layout_ = PipelineLayout(),
+                               Pipeline basePipelineHandle_ = Pipeline(),
+                               int32_t basePipelineIndex_ = 0 )
+      : flags( flags_ )
+      , stage( stage_ )
+      , layout( layout_ )
+      , basePipelineHandle( basePipelineHandle_ )
+      , basePipelineIndex( basePipelineIndex_ )
+    {}
+
+    ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
+    }
+
+    ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
+      return *this;
+    }
+
+    ComputePipelineCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ComputePipelineCreateInfo & setFlags( PipelineCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ComputePipelineCreateInfo & setStage( PipelineShaderStageCreateInfo stage_ )
+    {
+      stage = stage_;
+      return *this;
+    }
+
+    ComputePipelineCreateInfo & setLayout( PipelineLayout layout_ )
+    {
+      layout = layout_;
+      return *this;
+    }
+
+    ComputePipelineCreateInfo & setBasePipelineHandle( Pipeline basePipelineHandle_ )
+    {
+      basePipelineHandle = basePipelineHandle_;
+      return *this;
+    }
+
+    ComputePipelineCreateInfo & setBasePipelineIndex( int32_t basePipelineIndex_ )
+    {
+      basePipelineIndex = basePipelineIndex_;
+      return *this;
+    }
+
+    operator VkComputePipelineCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkComputePipelineCreateInfo*>( this );
+    }
+
+    operator VkComputePipelineCreateInfo &()
+    {
+      return *reinterpret_cast<VkComputePipelineCreateInfo*>( this );
+    }
+
+    bool operator==( ComputePipelineCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( stage == rhs.stage )
+          && ( layout == rhs.layout )
+          && ( basePipelineHandle == rhs.basePipelineHandle )
+          && ( basePipelineIndex == rhs.basePipelineIndex );
+    }
+
+    bool operator!=( ComputePipelineCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eComputePipelineCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    PipelineCreateFlags flags;
+    PipelineShaderStageCreateInfo stage;
+    PipelineLayout layout;
+    Pipeline basePipelineHandle;
+    int32_t basePipelineIndex;
+  };
+  static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" );
+
+  struct ConditionalRenderingBeginInfoEXT
+  {
+    ConditionalRenderingBeginInfoEXT( Buffer buffer_ = Buffer(),
+                                      DeviceSize offset_ = 0,
+                                      ConditionalRenderingFlagsEXT flags_ = ConditionalRenderingFlagsEXT() )
+      : buffer( buffer_ )
+      , offset( offset_ )
+      , flags( flags_ )
+    {}
+
+    ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) );
+    }
+
+    ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) );
+      return *this;
+    }
+
+    ConditionalRenderingBeginInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ConditionalRenderingBeginInfoEXT & setBuffer( Buffer buffer_ )
+    {
+      buffer = buffer_;
+      return *this;
+    }
+
+    ConditionalRenderingBeginInfoEXT & setOffset( DeviceSize offset_ )
+    {
+      offset = offset_;
+      return *this;
+    }
+
+    ConditionalRenderingBeginInfoEXT & setFlags( ConditionalRenderingFlagsEXT flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    operator VkConditionalRenderingBeginInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>( this );
+    }
+
+    operator VkConditionalRenderingBeginInfoEXT &()
+    {
+      return *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>( this );
+    }
+
+    bool operator==( ConditionalRenderingBeginInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( buffer == rhs.buffer )
+          && ( offset == rhs.offset )
+          && ( flags == rhs.flags );
+    }
+
+    bool operator!=( ConditionalRenderingBeginInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    Buffer buffer;
+    DeviceSize offset;
+    ConditionalRenderingFlagsEXT flags;
+  };
+  static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" );
+
+  struct ConformanceVersionKHR
+  {
+    ConformanceVersionKHR( uint8_t major_ = 0,
+                           uint8_t minor_ = 0,
+                           uint8_t subminor_ = 0,
+                           uint8_t patch_ = 0 )
+      : major( major_ )
+      , minor( minor_ )
+      , subminor( subminor_ )
+      , patch( patch_ )
+    {}
+
+    ConformanceVersionKHR( VkConformanceVersionKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) );
+    }
+
+    ConformanceVersionKHR& operator=( VkConformanceVersionKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) );
+      return *this;
+    }
+
+    ConformanceVersionKHR & setMajor( uint8_t major_ )
+    {
+      major = major_;
+      return *this;
+    }
+
+    ConformanceVersionKHR & setMinor( uint8_t minor_ )
+    {
+      minor = minor_;
+      return *this;
+    }
+
+    ConformanceVersionKHR & setSubminor( uint8_t subminor_ )
+    {
+      subminor = subminor_;
+      return *this;
+    }
+
+    ConformanceVersionKHR & setPatch( uint8_t patch_ )
+    {
+      patch = patch_;
+      return *this;
+    }
+
+    operator VkConformanceVersionKHR const&() const
+    {
+      return *reinterpret_cast<const VkConformanceVersionKHR*>( this );
+    }
+
+    operator VkConformanceVersionKHR &()
+    {
+      return *reinterpret_cast<VkConformanceVersionKHR*>( this );
+    }
+
+    bool operator==( ConformanceVersionKHR const& rhs ) const
+    {
+      return ( major == rhs.major )
+          && ( minor == rhs.minor )
+          && ( subminor == rhs.subminor )
+          && ( patch == rhs.patch );
+    }
+
+    bool operator!=( ConformanceVersionKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint8_t major;
+    uint8_t minor;
+    uint8_t subminor;
+    uint8_t patch;
+  };
+  static_assert( sizeof( ConformanceVersionKHR ) == sizeof( VkConformanceVersionKHR ), "struct and wrapper have different size!" );
 
   struct CopyDescriptorSet
   {
@@ -10005,8 +21346,7 @@ public:
       , dstBinding( dstBinding_ )
       , dstArrayElement( dstArrayElement_ )
       , descriptorCount( descriptorCount_ )
-    {
-    }
+    {}
 
     CopyDescriptorSet( VkCopyDescriptorSet const & rhs )
     {
@@ -10018,49 +21358,50 @@ public:
       memcpy( this, &rhs, sizeof( CopyDescriptorSet ) );
       return *this;
     }
-    CopyDescriptorSet& setPNext( const void* pNext_ )
+
+    CopyDescriptorSet & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    CopyDescriptorSet& setSrcSet( DescriptorSet srcSet_ )
+    CopyDescriptorSet & setSrcSet( DescriptorSet srcSet_ )
     {
       srcSet = srcSet_;
       return *this;
     }
 
-    CopyDescriptorSet& setSrcBinding( uint32_t srcBinding_ )
+    CopyDescriptorSet & setSrcBinding( uint32_t srcBinding_ )
     {
       srcBinding = srcBinding_;
       return *this;
     }
 
-    CopyDescriptorSet& setSrcArrayElement( uint32_t srcArrayElement_ )
+    CopyDescriptorSet & setSrcArrayElement( uint32_t srcArrayElement_ )
     {
       srcArrayElement = srcArrayElement_;
       return *this;
     }
 
-    CopyDescriptorSet& setDstSet( DescriptorSet dstSet_ )
+    CopyDescriptorSet & setDstSet( DescriptorSet dstSet_ )
     {
       dstSet = dstSet_;
       return *this;
     }
 
-    CopyDescriptorSet& setDstBinding( uint32_t dstBinding_ )
+    CopyDescriptorSet & setDstBinding( uint32_t dstBinding_ )
     {
       dstBinding = dstBinding_;
       return *this;
     }
 
-    CopyDescriptorSet& setDstArrayElement( uint32_t dstArrayElement_ )
+    CopyDescriptorSet & setDstArrayElement( uint32_t dstArrayElement_ )
     {
       dstArrayElement = dstArrayElement_;
       return *this;
     }
 
-    CopyDescriptorSet& setDescriptorCount( uint32_t descriptorCount_ )
+    CopyDescriptorSet & setDescriptorCount( uint32_t descriptorCount_ )
     {
       descriptorCount = descriptorCount_;
       return *this;
@@ -10068,12 +21409,12 @@ public:
 
     operator VkCopyDescriptorSet const&() const
     {
-      return *reinterpret_cast<const VkCopyDescriptorSet*>(this);
+      return *reinterpret_cast<const VkCopyDescriptorSet*>( this );
     }
 
     operator VkCopyDescriptorSet &()
     {
-      return *reinterpret_cast<VkCopyDescriptorSet*>(this);
+      return *reinterpret_cast<VkCopyDescriptorSet*>( this );
     }
 
     bool operator==( CopyDescriptorSet const& rhs ) const
@@ -10109,185 +21450,1460 @@ public:
   };
   static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "struct and wrapper have different size!" );
 
-  struct BufferViewCreateInfo
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct D3D12FenceSubmitInfoKHR
   {
-    BufferViewCreateInfo( BufferViewCreateFlags flags_ = BufferViewCreateFlags(),
-                          Buffer buffer_ = Buffer(),
-                          Format format_ = Format::eUndefined,
-                          DeviceSize offset_ = 0,
-                          DeviceSize range_ = 0 )
-      : flags( flags_ )
-      , buffer( buffer_ )
-      , format( format_ )
-      , offset( offset_ )
-      , range( range_ )
+    D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0,
+                             const uint64_t* pWaitSemaphoreValues_ = nullptr,
+                             uint32_t signalSemaphoreValuesCount_ = 0,
+                             const uint64_t* pSignalSemaphoreValues_ = nullptr )
+      : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
+      , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
+      , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ )
+      , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
+    {}
+
+    D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs )
     {
+      memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) );
     }
 
-    BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs )
+    D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs )
     {
-      memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) );
-    }
-
-    BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) );
+      memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) );
       return *this;
     }
-    BufferViewCreateInfo& setPNext( const void* pNext_ )
+
+    D3D12FenceSubmitInfoKHR & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    BufferViewCreateInfo& setFlags( BufferViewCreateFlags flags_ )
+    D3D12FenceSubmitInfoKHR & setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ )
+    {
+      waitSemaphoreValuesCount = waitSemaphoreValuesCount_;
+      return *this;
+    }
+
+    D3D12FenceSubmitInfoKHR & setPWaitSemaphoreValues( const uint64_t* pWaitSemaphoreValues_ )
+    {
+      pWaitSemaphoreValues = pWaitSemaphoreValues_;
+      return *this;
+    }
+
+    D3D12FenceSubmitInfoKHR & setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ )
+    {
+      signalSemaphoreValuesCount = signalSemaphoreValuesCount_;
+      return *this;
+    }
+
+    D3D12FenceSubmitInfoKHR & setPSignalSemaphoreValues( const uint64_t* pSignalSemaphoreValues_ )
+    {
+      pSignalSemaphoreValues = pSignalSemaphoreValues_;
+      return *this;
+    }
+
+    operator VkD3D12FenceSubmitInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>( this );
+    }
+
+    operator VkD3D12FenceSubmitInfoKHR &()
+    {
+      return *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>( this );
+    }
+
+    bool operator==( D3D12FenceSubmitInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount )
+          && ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues )
+          && ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount )
+          && ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues );
+    }
+
+    bool operator!=( D3D12FenceSubmitInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t waitSemaphoreValuesCount;
+    const uint64_t* pWaitSemaphoreValues;
+    uint32_t signalSemaphoreValuesCount;
+    const uint64_t* pSignalSemaphoreValues;
+  };
+  static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  struct DebugMarkerMarkerInfoEXT
+  {
+    DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr,
+                              std::array<float,4> const& color_ = { { 0 } } )
+      : pMarkerName( pMarkerName_ )
+    {
+      memcpy( &color, color_.data(), 4 * sizeof( float ) );
+    }
+
+    DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) );
+    }
+
+    DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) );
+      return *this;
+    }
+
+    DebugMarkerMarkerInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DebugMarkerMarkerInfoEXT & setPMarkerName( const char* pMarkerName_ )
+    {
+      pMarkerName = pMarkerName_;
+      return *this;
+    }
+
+    DebugMarkerMarkerInfoEXT & setColor( std::array<float,4> color_ )
+    {
+      memcpy( color, color_.data(), 4 * sizeof( float ) );
+      return *this;
+    }
+
+    operator VkDebugMarkerMarkerInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( this );
+    }
+
+    operator VkDebugMarkerMarkerInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>( this );
+    }
+
+    bool operator==( DebugMarkerMarkerInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( pMarkerName == rhs.pMarkerName )
+          && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 );
+    }
+
+    bool operator!=( DebugMarkerMarkerInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    const char* pMarkerName;
+    float color[4];
+  };
+  static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DebugMarkerObjectNameInfoEXT
+  {
+    DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown,
+                                  uint64_t object_ = 0,
+                                  const char* pObjectName_ = nullptr )
+      : objectType( objectType_ )
+      , object( object_ )
+      , pObjectName( pObjectName_ )
+    {}
+
+    DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
+    }
+
+    DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
+      return *this;
+    }
+
+    DebugMarkerObjectNameInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DebugMarkerObjectNameInfoEXT & setObjectType( DebugReportObjectTypeEXT objectType_ )
+    {
+      objectType = objectType_;
+      return *this;
+    }
+
+    DebugMarkerObjectNameInfoEXT & setObject( uint64_t object_ )
+    {
+      object = object_;
+      return *this;
+    }
+
+    DebugMarkerObjectNameInfoEXT & setPObjectName( const char* pObjectName_ )
+    {
+      pObjectName = pObjectName_;
+      return *this;
+    }
+
+    operator VkDebugMarkerObjectNameInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( this );
+    }
+
+    operator VkDebugMarkerObjectNameInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>( this );
+    }
+
+    bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( objectType == rhs.objectType )
+          && ( object == rhs.object )
+          && ( pObjectName == rhs.pObjectName );
+    }
+
+    bool operator!=( DebugMarkerObjectNameInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    DebugReportObjectTypeEXT objectType;
+    uint64_t object;
+    const char* pObjectName;
+  };
+  static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DebugMarkerObjectTagInfoEXT
+  {
+    DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown,
+                                 uint64_t object_ = 0,
+                                 uint64_t tagName_ = 0,
+                                 size_t tagSize_ = 0,
+                                 const void* pTag_ = nullptr )
+      : objectType( objectType_ )
+      , object( object_ )
+      , tagName( tagName_ )
+      , tagSize( tagSize_ )
+      , pTag( pTag_ )
+    {}
+
+    DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
+    }
+
+    DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
+      return *this;
+    }
+
+    DebugMarkerObjectTagInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DebugMarkerObjectTagInfoEXT & setObjectType( DebugReportObjectTypeEXT objectType_ )
+    {
+      objectType = objectType_;
+      return *this;
+    }
+
+    DebugMarkerObjectTagInfoEXT & setObject( uint64_t object_ )
+    {
+      object = object_;
+      return *this;
+    }
+
+    DebugMarkerObjectTagInfoEXT & setTagName( uint64_t tagName_ )
+    {
+      tagName = tagName_;
+      return *this;
+    }
+
+    DebugMarkerObjectTagInfoEXT & setTagSize( size_t tagSize_ )
+    {
+      tagSize = tagSize_;
+      return *this;
+    }
+
+    DebugMarkerObjectTagInfoEXT & setPTag( const void* pTag_ )
+    {
+      pTag = pTag_;
+      return *this;
+    }
+
+    operator VkDebugMarkerObjectTagInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( this );
+    }
+
+    operator VkDebugMarkerObjectTagInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>( this );
+    }
+
+    bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( objectType == rhs.objectType )
+          && ( object == rhs.object )
+          && ( tagName == rhs.tagName )
+          && ( tagSize == rhs.tagSize )
+          && ( pTag == rhs.pTag );
+    }
+
+    bool operator!=( DebugMarkerObjectTagInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    DebugReportObjectTypeEXT objectType;
+    uint64_t object;
+    uint64_t tagName;
+    size_t tagSize;
+    const void* pTag;
+  };
+  static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DebugReportCallbackCreateInfoEXT
+  {
+    DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(),
+                                      PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr,
+                                      void* pUserData_ = nullptr )
+      : flags( flags_ )
+      , pfnCallback( pfnCallback_ )
+      , pUserData( pUserData_ )
+    {}
+
+    DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
+    }
+
+    DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
+      return *this;
+    }
+
+    DebugReportCallbackCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DebugReportCallbackCreateInfoEXT & setFlags( DebugReportFlagsEXT flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    BufferViewCreateInfo& setBuffer( Buffer buffer_ )
+    DebugReportCallbackCreateInfoEXT & setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ )
+    {
+      pfnCallback = pfnCallback_;
+      return *this;
+    }
+
+    DebugReportCallbackCreateInfoEXT & setPUserData( void* pUserData_ )
+    {
+      pUserData = pUserData_;
+      return *this;
+    }
+
+    operator VkDebugReportCallbackCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( this );
+    }
+
+    operator VkDebugReportCallbackCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>( this );
+    }
+
+    bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( pfnCallback == rhs.pfnCallback )
+          && ( pUserData == rhs.pUserData );
+    }
+
+    bool operator!=( DebugReportCallbackCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    DebugReportFlagsEXT flags;
+    PFN_vkDebugReportCallbackEXT pfnCallback;
+    void* pUserData;
+  };
+  static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DebugUtilsLabelEXT
+  {
+    DebugUtilsLabelEXT( const char* pLabelName_ = nullptr,
+                        std::array<float,4> const& color_ = { { 0 } } )
+      : pLabelName( pLabelName_ )
+    {
+      memcpy( &color, color_.data(), 4 * sizeof( float ) );
+    }
+
+    DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsLabelEXT ) );
+    }
+
+    DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsLabelEXT ) );
+      return *this;
+    }
+
+    DebugUtilsLabelEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DebugUtilsLabelEXT & setPLabelName( const char* pLabelName_ )
+    {
+      pLabelName = pLabelName_;
+      return *this;
+    }
+
+    DebugUtilsLabelEXT & setColor( std::array<float,4> color_ )
+    {
+      memcpy( color, color_.data(), 4 * sizeof( float ) );
+      return *this;
+    }
+
+    operator VkDebugUtilsLabelEXT const&() const
+    {
+      return *reinterpret_cast<const VkDebugUtilsLabelEXT*>( this );
+    }
+
+    operator VkDebugUtilsLabelEXT &()
+    {
+      return *reinterpret_cast<VkDebugUtilsLabelEXT*>( this );
+    }
+
+    bool operator==( DebugUtilsLabelEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( pLabelName == rhs.pLabelName )
+          && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 );
+    }
+
+    bool operator!=( DebugUtilsLabelEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDebugUtilsLabelEXT;
+
+  public:
+    const void* pNext = nullptr;
+    const char* pLabelName;
+    float color[4];
+  };
+  static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "struct and wrapper have different size!" );
+
+  struct DebugUtilsObjectNameInfoEXT
+  {
+    DebugUtilsObjectNameInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
+                                 uint64_t objectHandle_ = 0,
+                                 const char* pObjectName_ = nullptr )
+      : objectType( objectType_ )
+      , objectHandle( objectHandle_ )
+      , pObjectName( pObjectName_ )
+    {}
+
+    DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
+    }
+
+    DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
+      return *this;
+    }
+
+    DebugUtilsObjectNameInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DebugUtilsObjectNameInfoEXT & setObjectType( ObjectType objectType_ )
+    {
+      objectType = objectType_;
+      return *this;
+    }
+
+    DebugUtilsObjectNameInfoEXT & setObjectHandle( uint64_t objectHandle_ )
+    {
+      objectHandle = objectHandle_;
+      return *this;
+    }
+
+    DebugUtilsObjectNameInfoEXT & setPObjectName( const char* pObjectName_ )
+    {
+      pObjectName = pObjectName_;
+      return *this;
+    }
+
+    operator VkDebugUtilsObjectNameInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>( this );
+    }
+
+    operator VkDebugUtilsObjectNameInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>( this );
+    }
+
+    bool operator==( DebugUtilsObjectNameInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( objectType == rhs.objectType )
+          && ( objectHandle == rhs.objectHandle )
+          && ( pObjectName == rhs.pObjectName );
+    }
+
+    bool operator!=( DebugUtilsObjectNameInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    ObjectType objectType;
+    uint64_t objectHandle;
+    const char* pObjectName;
+  };
+  static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DebugUtilsMessengerCallbackDataEXT
+  {
+    DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_ = DebugUtilsMessengerCallbackDataFlagsEXT(),
+                                        const char* pMessageIdName_ = nullptr,
+                                        int32_t messageIdNumber_ = 0,
+                                        const char* pMessage_ = nullptr,
+                                        uint32_t queueLabelCount_ = 0,
+                                        DebugUtilsLabelEXT* pQueueLabels_ = nullptr,
+                                        uint32_t cmdBufLabelCount_ = 0,
+                                        DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr,
+                                        uint32_t objectCount_ = 0,
+                                        DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr )
+      : flags( flags_ )
+      , pMessageIdName( pMessageIdName_ )
+      , messageIdNumber( messageIdNumber_ )
+      , pMessage( pMessage_ )
+      , queueLabelCount( queueLabelCount_ )
+      , pQueueLabels( pQueueLabels_ )
+      , cmdBufLabelCount( cmdBufLabelCount_ )
+      , pCmdBufLabels( pCmdBufLabels_ )
+      , objectCount( objectCount_ )
+      , pObjects( pObjects_ )
+    {}
+
+    DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) );
+    }
+
+    DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) );
+      return *this;
+    }
+
+    DebugUtilsMessengerCallbackDataEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCallbackDataEXT & setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCallbackDataEXT & setPMessageIdName( const char* pMessageIdName_ )
+    {
+      pMessageIdName = pMessageIdName_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCallbackDataEXT & setMessageIdNumber( int32_t messageIdNumber_ )
+    {
+      messageIdNumber = messageIdNumber_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCallbackDataEXT & setPMessage( const char* pMessage_ )
+    {
+      pMessage = pMessage_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCallbackDataEXT & setQueueLabelCount( uint32_t queueLabelCount_ )
+    {
+      queueLabelCount = queueLabelCount_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCallbackDataEXT & setPQueueLabels( DebugUtilsLabelEXT* pQueueLabels_ )
+    {
+      pQueueLabels = pQueueLabels_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCallbackDataEXT & setCmdBufLabelCount( uint32_t cmdBufLabelCount_ )
+    {
+      cmdBufLabelCount = cmdBufLabelCount_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCallbackDataEXT & setPCmdBufLabels( DebugUtilsLabelEXT* pCmdBufLabels_ )
+    {
+      pCmdBufLabels = pCmdBufLabels_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCallbackDataEXT & setObjectCount( uint32_t objectCount_ )
+    {
+      objectCount = objectCount_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCallbackDataEXT & setPObjects( DebugUtilsObjectNameInfoEXT* pObjects_ )
+    {
+      pObjects = pObjects_;
+      return *this;
+    }
+
+    operator VkDebugUtilsMessengerCallbackDataEXT const&() const
+    {
+      return *reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>( this );
+    }
+
+    operator VkDebugUtilsMessengerCallbackDataEXT &()
+    {
+      return *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>( this );
+    }
+
+    bool operator==( DebugUtilsMessengerCallbackDataEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( pMessageIdName == rhs.pMessageIdName )
+          && ( messageIdNumber == rhs.messageIdNumber )
+          && ( pMessage == rhs.pMessage )
+          && ( queueLabelCount == rhs.queueLabelCount )
+          && ( pQueueLabels == rhs.pQueueLabels )
+          && ( cmdBufLabelCount == rhs.cmdBufLabelCount )
+          && ( pCmdBufLabels == rhs.pCmdBufLabels )
+          && ( objectCount == rhs.objectCount )
+          && ( pObjects == rhs.pObjects );
+    }
+
+    bool operator!=( DebugUtilsMessengerCallbackDataEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT;
+
+  public:
+    const void* pNext = nullptr;
+    DebugUtilsMessengerCallbackDataFlagsEXT flags;
+    const char* pMessageIdName;
+    int32_t messageIdNumber;
+    const char* pMessage;
+    uint32_t queueLabelCount;
+    DebugUtilsLabelEXT* pQueueLabels;
+    uint32_t cmdBufLabelCount;
+    DebugUtilsLabelEXT* pCmdBufLabels;
+    uint32_t objectCount;
+    DebugUtilsObjectNameInfoEXT* pObjects;
+  };
+  static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "struct and wrapper have different size!" );
+
+  struct DebugUtilsMessengerCreateInfoEXT
+  {
+    DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT flags_ = DebugUtilsMessengerCreateFlagsEXT(),
+                                      DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = DebugUtilsMessageSeverityFlagsEXT(),
+                                      DebugUtilsMessageTypeFlagsEXT messageType_ = DebugUtilsMessageTypeFlagsEXT(),
+                                      PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr,
+                                      void* pUserData_ = nullptr )
+      : flags( flags_ )
+      , messageSeverity( messageSeverity_ )
+      , messageType( messageType_ )
+      , pfnUserCallback( pfnUserCallback_ )
+      , pUserData( pUserData_ )
+    {}
+
+    DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) );
+    }
+
+    DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) );
+      return *this;
+    }
+
+    DebugUtilsMessengerCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCreateInfoEXT & setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCreateInfoEXT & setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ )
+    {
+      messageSeverity = messageSeverity_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCreateInfoEXT & setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ )
+    {
+      messageType = messageType_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCreateInfoEXT & setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ )
+    {
+      pfnUserCallback = pfnUserCallback_;
+      return *this;
+    }
+
+    DebugUtilsMessengerCreateInfoEXT & setPUserData( void* pUserData_ )
+    {
+      pUserData = pUserData_;
+      return *this;
+    }
+
+    operator VkDebugUtilsMessengerCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( this );
+    }
+
+    operator VkDebugUtilsMessengerCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>( this );
+    }
+
+    bool operator==( DebugUtilsMessengerCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( messageSeverity == rhs.messageSeverity )
+          && ( messageType == rhs.messageType )
+          && ( pfnUserCallback == rhs.pfnUserCallback )
+          && ( pUserData == rhs.pUserData );
+    }
+
+    bool operator!=( DebugUtilsMessengerCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    DebugUtilsMessengerCreateFlagsEXT flags;
+    DebugUtilsMessageSeverityFlagsEXT messageSeverity;
+    DebugUtilsMessageTypeFlagsEXT messageType;
+    PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
+    void* pUserData;
+  };
+  static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DebugUtilsObjectTagInfoEXT
+  {
+    DebugUtilsObjectTagInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
+                                uint64_t objectHandle_ = 0,
+                                uint64_t tagName_ = 0,
+                                size_t tagSize_ = 0,
+                                const void* pTag_ = nullptr )
+      : objectType( objectType_ )
+      , objectHandle( objectHandle_ )
+      , tagName( tagName_ )
+      , tagSize( tagSize_ )
+      , pTag( pTag_ )
+    {}
+
+    DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
+    }
+
+    DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
+      return *this;
+    }
+
+    DebugUtilsObjectTagInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DebugUtilsObjectTagInfoEXT & setObjectType( ObjectType objectType_ )
+    {
+      objectType = objectType_;
+      return *this;
+    }
+
+    DebugUtilsObjectTagInfoEXT & setObjectHandle( uint64_t objectHandle_ )
+    {
+      objectHandle = objectHandle_;
+      return *this;
+    }
+
+    DebugUtilsObjectTagInfoEXT & setTagName( uint64_t tagName_ )
+    {
+      tagName = tagName_;
+      return *this;
+    }
+
+    DebugUtilsObjectTagInfoEXT & setTagSize( size_t tagSize_ )
+    {
+      tagSize = tagSize_;
+      return *this;
+    }
+
+    DebugUtilsObjectTagInfoEXT & setPTag( const void* pTag_ )
+    {
+      pTag = pTag_;
+      return *this;
+    }
+
+    operator VkDebugUtilsObjectTagInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>( this );
+    }
+
+    operator VkDebugUtilsObjectTagInfoEXT &()
+    {
+      return *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>( this );
+    }
+
+    bool operator==( DebugUtilsObjectTagInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( objectType == rhs.objectType )
+          && ( objectHandle == rhs.objectHandle )
+          && ( tagName == rhs.tagName )
+          && ( tagSize == rhs.tagSize )
+          && ( pTag == rhs.pTag );
+    }
+
+    bool operator!=( DebugUtilsObjectTagInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    ObjectType objectType;
+    uint64_t objectHandle;
+    uint64_t tagName;
+    size_t tagSize;
+    const void* pTag;
+  };
+  static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DedicatedAllocationBufferCreateInfoNV
+  {
+    DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
+      : dedicatedAllocation( dedicatedAllocation_ )
+    {}
+
+    DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) );
+    }
+
+    DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) );
+      return *this;
+    }
+
+    DedicatedAllocationBufferCreateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DedicatedAllocationBufferCreateInfoNV & setDedicatedAllocation( Bool32 dedicatedAllocation_ )
+    {
+      dedicatedAllocation = dedicatedAllocation_;
+      return *this;
+    }
+
+    operator VkDedicatedAllocationBufferCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>( this );
+    }
+
+    operator VkDedicatedAllocationBufferCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>( this );
+    }
+
+    bool operator==( DedicatedAllocationBufferCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( dedicatedAllocation == rhs.dedicatedAllocation );
+    }
+
+    bool operator!=( DedicatedAllocationBufferCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    Bool32 dedicatedAllocation;
+  };
+  static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" );
+
+  struct DedicatedAllocationImageCreateInfoNV
+  {
+    DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
+      : dedicatedAllocation( dedicatedAllocation_ )
+    {}
+
+    DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) );
+    }
+
+    DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) );
+      return *this;
+    }
+
+    DedicatedAllocationImageCreateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DedicatedAllocationImageCreateInfoNV & setDedicatedAllocation( Bool32 dedicatedAllocation_ )
+    {
+      dedicatedAllocation = dedicatedAllocation_;
+      return *this;
+    }
+
+    operator VkDedicatedAllocationImageCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>( this );
+    }
+
+    operator VkDedicatedAllocationImageCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>( this );
+    }
+
+    bool operator==( DedicatedAllocationImageCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( dedicatedAllocation == rhs.dedicatedAllocation );
+    }
+
+    bool operator!=( DedicatedAllocationImageCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    Bool32 dedicatedAllocation;
+  };
+  static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" );
+
+  struct DedicatedAllocationMemoryAllocateInfoNV
+  {
+    DedicatedAllocationMemoryAllocateInfoNV( Image image_ = Image(),
+                                             Buffer buffer_ = Buffer() )
+      : image( image_ )
+      , buffer( buffer_ )
+    {}
+
+    DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) );
+    }
+
+    DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) );
+      return *this;
+    }
+
+    DedicatedAllocationMemoryAllocateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DedicatedAllocationMemoryAllocateInfoNV & setImage( Image image_ )
+    {
+      image = image_;
+      return *this;
+    }
+
+    DedicatedAllocationMemoryAllocateInfoNV & setBuffer( Buffer buffer_ )
     {
       buffer = buffer_;
       return *this;
     }
 
-    BufferViewCreateInfo& setFormat( Format format_ )
+    operator VkDedicatedAllocationMemoryAllocateInfoNV const&() const
     {
-      format = format_;
+      return *reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>( this );
+    }
+
+    operator VkDedicatedAllocationMemoryAllocateInfoNV &()
+    {
+      return *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>( this );
+    }
+
+    bool operator==( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( image == rhs.image )
+          && ( buffer == rhs.buffer );
+    }
+
+    bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    Image image;
+    Buffer buffer;
+  };
+  static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
+
+  struct DescriptorBufferInfo
+  {
+    DescriptorBufferInfo( Buffer buffer_ = Buffer(),
+                          DeviceSize offset_ = 0,
+                          DeviceSize range_ = 0 )
+      : buffer( buffer_ )
+      , offset( offset_ )
+      , range( range_ )
+    {}
+
+    DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
+    }
+
+    DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
       return *this;
     }
 
-    BufferViewCreateInfo& setOffset( DeviceSize offset_ )
+    DescriptorBufferInfo & setBuffer( Buffer buffer_ )
+    {
+      buffer = buffer_;
+      return *this;
+    }
+
+    DescriptorBufferInfo & setOffset( DeviceSize offset_ )
     {
       offset = offset_;
       return *this;
     }
 
-    BufferViewCreateInfo& setRange( DeviceSize range_ )
+    DescriptorBufferInfo & setRange( DeviceSize range_ )
     {
       range = range_;
       return *this;
     }
 
-    operator VkBufferViewCreateInfo const&() const
+    operator VkDescriptorBufferInfo const&() const
     {
-      return *reinterpret_cast<const VkBufferViewCreateInfo*>(this);
+      return *reinterpret_cast<const VkDescriptorBufferInfo*>( this );
     }
 
-    operator VkBufferViewCreateInfo &()
+    operator VkDescriptorBufferInfo &()
     {
-      return *reinterpret_cast<VkBufferViewCreateInfo*>(this);
+      return *reinterpret_cast<VkDescriptorBufferInfo*>( this );
     }
 
-    bool operator==( BufferViewCreateInfo const& rhs ) const
+    bool operator==( DescriptorBufferInfo const& rhs ) const
     {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( buffer == rhs.buffer )
-          && ( format == rhs.format )
+      return ( buffer == rhs.buffer )
           && ( offset == rhs.offset )
           && ( range == rhs.range );
     }
 
-    bool operator!=( BufferViewCreateInfo const& rhs ) const
+    bool operator!=( DescriptorBufferInfo const& rhs ) const
     {
       return !operator==( rhs );
     }
 
-  private:
-    StructureType sType = StructureType::eBufferViewCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    BufferViewCreateFlags flags;
     Buffer buffer;
-    Format format;
     DeviceSize offset;
     DeviceSize range;
   };
-  static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" );
+  static_assert( sizeof( DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" );
 
-  struct ShaderModuleCreateInfo
+  struct DescriptorImageInfo
   {
-    ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = ShaderModuleCreateFlags(),
-                            size_t codeSize_ = 0,
-                            const uint32_t* pCode_ = nullptr )
-      : flags( flags_ )
-      , codeSize( codeSize_ )
-      , pCode( pCode_ )
+    DescriptorImageInfo( Sampler sampler_ = Sampler(),
+                         ImageView imageView_ = ImageView(),
+                         ImageLayout imageLayout_ = ImageLayout::eUndefined )
+      : sampler( sampler_ )
+      , imageView( imageView_ )
+      , imageLayout( imageLayout_ )
+    {}
+
+    DescriptorImageInfo( VkDescriptorImageInfo const & rhs )
     {
+      memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
     }
 
-    ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs )
+    DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs )
     {
-      memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) );
-    }
-
-    ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) );
+      memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
       return *this;
     }
-    ShaderModuleCreateInfo& setPNext( const void* pNext_ )
+
+    DescriptorImageInfo & setSampler( Sampler sampler_ )
+    {
+      sampler = sampler_;
+      return *this;
+    }
+
+    DescriptorImageInfo & setImageView( ImageView imageView_ )
+    {
+      imageView = imageView_;
+      return *this;
+    }
+
+    DescriptorImageInfo & setImageLayout( ImageLayout imageLayout_ )
+    {
+      imageLayout = imageLayout_;
+      return *this;
+    }
+
+    operator VkDescriptorImageInfo const&() const
+    {
+      return *reinterpret_cast<const VkDescriptorImageInfo*>( this );
+    }
+
+    operator VkDescriptorImageInfo &()
+    {
+      return *reinterpret_cast<VkDescriptorImageInfo*>( this );
+    }
+
+    bool operator==( DescriptorImageInfo const& rhs ) const
+    {
+      return ( sampler == rhs.sampler )
+          && ( imageView == rhs.imageView )
+          && ( imageLayout == rhs.imageLayout );
+    }
+
+    bool operator!=( DescriptorImageInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    Sampler sampler;
+    ImageView imageView;
+    ImageLayout imageLayout;
+  };
+  static_assert( sizeof( DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" );
+
+  struct DescriptorPoolSize
+  {
+    DescriptorPoolSize( DescriptorType type_ = DescriptorType::eSampler,
+                        uint32_t descriptorCount_ = 0 )
+      : type( type_ )
+      , descriptorCount( descriptorCount_ )
+    {}
+
+    DescriptorPoolSize( VkDescriptorPoolSize const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
+    }
+
+    DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
+      return *this;
+    }
+
+    DescriptorPoolSize & setType( DescriptorType type_ )
+    {
+      type = type_;
+      return *this;
+    }
+
+    DescriptorPoolSize & setDescriptorCount( uint32_t descriptorCount_ )
+    {
+      descriptorCount = descriptorCount_;
+      return *this;
+    }
+
+    operator VkDescriptorPoolSize const&() const
+    {
+      return *reinterpret_cast<const VkDescriptorPoolSize*>( this );
+    }
+
+    operator VkDescriptorPoolSize &()
+    {
+      return *reinterpret_cast<VkDescriptorPoolSize*>( this );
+    }
+
+    bool operator==( DescriptorPoolSize const& rhs ) const
+    {
+      return ( type == rhs.type )
+          && ( descriptorCount == rhs.descriptorCount );
+    }
+
+    bool operator!=( DescriptorPoolSize const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    DescriptorType type;
+    uint32_t descriptorCount;
+  };
+  static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" );
+
+  struct DescriptorPoolCreateInfo
+  {
+    DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(),
+                              uint32_t maxSets_ = 0,
+                              uint32_t poolSizeCount_ = 0,
+                              const DescriptorPoolSize* pPoolSizes_ = nullptr )
+      : flags( flags_ )
+      , maxSets( maxSets_ )
+      , poolSizeCount( poolSizeCount_ )
+      , pPoolSizes( pPoolSizes_ )
+    {}
+
+    DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
+    }
+
+    DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
+      return *this;
+    }
+
+    DescriptorPoolCreateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    ShaderModuleCreateInfo& setFlags( ShaderModuleCreateFlags flags_ )
+    DescriptorPoolCreateInfo & setFlags( DescriptorPoolCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    ShaderModuleCreateInfo& setCodeSize( size_t codeSize_ )
+    DescriptorPoolCreateInfo & setMaxSets( uint32_t maxSets_ )
     {
-      codeSize = codeSize_;
+      maxSets = maxSets_;
       return *this;
     }
 
-    ShaderModuleCreateInfo& setPCode( const uint32_t* pCode_ )
+    DescriptorPoolCreateInfo & setPoolSizeCount( uint32_t poolSizeCount_ )
     {
-      pCode = pCode_;
+      poolSizeCount = poolSizeCount_;
       return *this;
     }
 
-    operator VkShaderModuleCreateInfo const&() const
+    DescriptorPoolCreateInfo & setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ )
     {
-      return *reinterpret_cast<const VkShaderModuleCreateInfo*>(this);
+      pPoolSizes = pPoolSizes_;
+      return *this;
     }
 
-    operator VkShaderModuleCreateInfo &()
+    operator VkDescriptorPoolCreateInfo const&() const
     {
-      return *reinterpret_cast<VkShaderModuleCreateInfo*>(this);
+      return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>( this );
     }
 
-    bool operator==( ShaderModuleCreateInfo const& rhs ) const
+    operator VkDescriptorPoolCreateInfo &()
+    {
+      return *reinterpret_cast<VkDescriptorPoolCreateInfo*>( this );
+    }
+
+    bool operator==( DescriptorPoolCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
           && ( flags == rhs.flags )
-          && ( codeSize == rhs.codeSize )
-          && ( pCode == rhs.pCode );
+          && ( maxSets == rhs.maxSets )
+          && ( poolSizeCount == rhs.poolSizeCount )
+          && ( pPoolSizes == rhs.pPoolSizes );
     }
 
-    bool operator!=( ShaderModuleCreateInfo const& rhs ) const
+    bool operator!=( DescriptorPoolCreateInfo const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eShaderModuleCreateInfo;
+    StructureType sType = StructureType::eDescriptorPoolCreateInfo;
 
   public:
     const void* pNext = nullptr;
-    ShaderModuleCreateFlags flags;
-    size_t codeSize;
-    const uint32_t* pCode;
+    DescriptorPoolCreateFlags flags;
+    uint32_t maxSets;
+    uint32_t poolSizeCount;
+    const DescriptorPoolSize* pPoolSizes;
   };
-  static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "struct and wrapper have different size!" );
+  static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" );
+
+  struct DescriptorPoolInlineUniformBlockCreateInfoEXT
+  {
+    DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 )
+      : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
+    {}
+
+    DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) );
+    }
+
+    DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) );
+      return *this;
+    }
+
+    DescriptorPoolInlineUniformBlockCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DescriptorPoolInlineUniformBlockCreateInfoEXT & setMaxInlineUniformBlockBindings( uint32_t maxInlineUniformBlockBindings_ )
+    {
+      maxInlineUniformBlockBindings = maxInlineUniformBlockBindings_;
+      return *this;
+    }
+
+    operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>( this );
+    }
+
+    operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>( this );
+    }
+
+    bool operator==( DescriptorPoolInlineUniformBlockCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings );
+    }
+
+    bool operator!=( DescriptorPoolInlineUniformBlockCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t maxInlineUniformBlockBindings;
+  };
+  static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "struct and wrapper have different size!" );
 
   struct DescriptorSetAllocateInfo
   {
@@ -10297,8 +22913,7 @@ public:
       : descriptorPool( descriptorPool_ )
       , descriptorSetCount( descriptorSetCount_ )
       , pSetLayouts( pSetLayouts_ )
-    {
-    }
+    {}
 
     DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs )
     {
@@ -10310,25 +22925,26 @@ public:
       memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) );
       return *this;
     }
-    DescriptorSetAllocateInfo& setPNext( const void* pNext_ )
+
+    DescriptorSetAllocateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    DescriptorSetAllocateInfo& setDescriptorPool( DescriptorPool descriptorPool_ )
+    DescriptorSetAllocateInfo & setDescriptorPool( DescriptorPool descriptorPool_ )
     {
       descriptorPool = descriptorPool_;
       return *this;
     }
 
-    DescriptorSetAllocateInfo& setDescriptorSetCount( uint32_t descriptorSetCount_ )
+    DescriptorSetAllocateInfo & setDescriptorSetCount( uint32_t descriptorSetCount_ )
     {
       descriptorSetCount = descriptorSetCount_;
       return *this;
     }
 
-    DescriptorSetAllocateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
+    DescriptorSetAllocateInfo & setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
     {
       pSetLayouts = pSetLayouts_;
       return *this;
@@ -10336,12 +22952,12 @@ public:
 
     operator VkDescriptorSetAllocateInfo const&() const
     {
-      return *reinterpret_cast<const VkDescriptorSetAllocateInfo*>(this);
+      return *reinterpret_cast<const VkDescriptorSetAllocateInfo*>( this );
     }
 
     operator VkDescriptorSetAllocateInfo &()
     {
-      return *reinterpret_cast<VkDescriptorSetAllocateInfo*>(this);
+      return *reinterpret_cast<VkDescriptorSetAllocateInfo*>( this );
     }
 
     bool operator==( DescriptorSetAllocateInfo const& rhs ) const
@@ -10369,6 +22985,5234 @@ public:
   };
   static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "struct and wrapper have different size!" );
 
+  struct DescriptorSetLayoutBinding
+  {
+    DescriptorSetLayoutBinding( uint32_t binding_ = 0,
+                                DescriptorType descriptorType_ = DescriptorType::eSampler,
+                                uint32_t descriptorCount_ = 0,
+                                ShaderStageFlags stageFlags_ = ShaderStageFlags(),
+                                const Sampler* pImmutableSamplers_ = nullptr )
+      : binding( binding_ )
+      , descriptorType( descriptorType_ )
+      , descriptorCount( descriptorCount_ )
+      , stageFlags( stageFlags_ )
+      , pImmutableSamplers( pImmutableSamplers_ )
+    {}
+
+    DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
+    }
+
+    DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
+      return *this;
+    }
+
+    DescriptorSetLayoutBinding & setBinding( uint32_t binding_ )
+    {
+      binding = binding_;
+      return *this;
+    }
+
+    DescriptorSetLayoutBinding & setDescriptorType( DescriptorType descriptorType_ )
+    {
+      descriptorType = descriptorType_;
+      return *this;
+    }
+
+    DescriptorSetLayoutBinding & setDescriptorCount( uint32_t descriptorCount_ )
+    {
+      descriptorCount = descriptorCount_;
+      return *this;
+    }
+
+    DescriptorSetLayoutBinding & setStageFlags( ShaderStageFlags stageFlags_ )
+    {
+      stageFlags = stageFlags_;
+      return *this;
+    }
+
+    DescriptorSetLayoutBinding & setPImmutableSamplers( const Sampler* pImmutableSamplers_ )
+    {
+      pImmutableSamplers = pImmutableSamplers_;
+      return *this;
+    }
+
+    operator VkDescriptorSetLayoutBinding const&() const
+    {
+      return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>( this );
+    }
+
+    operator VkDescriptorSetLayoutBinding &()
+    {
+      return *reinterpret_cast<VkDescriptorSetLayoutBinding*>( this );
+    }
+
+    bool operator==( DescriptorSetLayoutBinding const& rhs ) const
+    {
+      return ( binding == rhs.binding )
+          && ( descriptorType == rhs.descriptorType )
+          && ( descriptorCount == rhs.descriptorCount )
+          && ( stageFlags == rhs.stageFlags )
+          && ( pImmutableSamplers == rhs.pImmutableSamplers );
+    }
+
+    bool operator!=( DescriptorSetLayoutBinding const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t binding;
+    DescriptorType descriptorType;
+    uint32_t descriptorCount;
+    ShaderStageFlags stageFlags;
+    const Sampler* pImmutableSamplers;
+  };
+  static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" );
+
+  struct DescriptorSetLayoutBindingFlagsCreateInfoEXT
+  {
+    DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0,
+                                                  const DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr )
+      : bindingCount( bindingCount_ )
+      , pBindingFlags( pBindingFlags_ )
+    {}
+
+    DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) );
+    }
+
+    DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) );
+      return *this;
+    }
+
+    DescriptorSetLayoutBindingFlagsCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DescriptorSetLayoutBindingFlagsCreateInfoEXT & setBindingCount( uint32_t bindingCount_ )
+    {
+      bindingCount = bindingCount_;
+      return *this;
+    }
+
+    DescriptorSetLayoutBindingFlagsCreateInfoEXT & setPBindingFlags( const DescriptorBindingFlagsEXT* pBindingFlags_ )
+    {
+      pBindingFlags = pBindingFlags_;
+      return *this;
+    }
+
+    operator VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>( this );
+    }
+
+    operator VkDescriptorSetLayoutBindingFlagsCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>( this );
+    }
+
+    bool operator==( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( bindingCount == rhs.bindingCount )
+          && ( pBindingFlags == rhs.pBindingFlags );
+    }
+
+    bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t bindingCount;
+    const DescriptorBindingFlagsEXT* pBindingFlags;
+  };
+  static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DescriptorSetLayoutCreateInfo
+  {
+    DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(),
+                                   uint32_t bindingCount_ = 0,
+                                   const DescriptorSetLayoutBinding* pBindings_ = nullptr )
+      : flags( flags_ )
+      , bindingCount( bindingCount_ )
+      , pBindings( pBindings_ )
+    {}
+
+    DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
+    }
+
+    DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
+      return *this;
+    }
+
+    DescriptorSetLayoutCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DescriptorSetLayoutCreateInfo & setFlags( DescriptorSetLayoutCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    DescriptorSetLayoutCreateInfo & setBindingCount( uint32_t bindingCount_ )
+    {
+      bindingCount = bindingCount_;
+      return *this;
+    }
+
+    DescriptorSetLayoutCreateInfo & setPBindings( const DescriptorSetLayoutBinding* pBindings_ )
+    {
+      pBindings = pBindings_;
+      return *this;
+    }
+
+    operator VkDescriptorSetLayoutCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( this );
+    }
+
+    operator VkDescriptorSetLayoutCreateInfo &()
+    {
+      return *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>( this );
+    }
+
+    bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( bindingCount == rhs.bindingCount )
+          && ( pBindings == rhs.pBindings );
+    }
+
+    bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    DescriptorSetLayoutCreateFlags flags;
+    uint32_t bindingCount;
+    const DescriptorSetLayoutBinding* pBindings;
+  };
+  static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" );
+
+  struct DescriptorSetLayoutSupport
+  {
+    operator VkDescriptorSetLayoutSupport const&() const
+    {
+      return *reinterpret_cast<const VkDescriptorSetLayoutSupport*>( this );
+    }
+
+    operator VkDescriptorSetLayoutSupport &()
+    {
+      return *reinterpret_cast<VkDescriptorSetLayoutSupport*>( this );
+    }
+
+    bool operator==( DescriptorSetLayoutSupport const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( supported == rhs.supported );
+    }
+
+    bool operator!=( DescriptorSetLayoutSupport const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDescriptorSetLayoutSupport;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 supported;
+  };
+  static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "struct and wrapper have different size!" );
+
+  struct DescriptorSetVariableDescriptorCountAllocateInfoEXT
+  {
+    DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0,
+                                                         const uint32_t* pDescriptorCounts_ = nullptr )
+      : descriptorSetCount( descriptorSetCount_ )
+      , pDescriptorCounts( pDescriptorCounts_ )
+    {}
+
+    DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) );
+    }
+
+    DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) );
+      return *this;
+    }
+
+    DescriptorSetVariableDescriptorCountAllocateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DescriptorSetVariableDescriptorCountAllocateInfoEXT & setDescriptorSetCount( uint32_t descriptorSetCount_ )
+    {
+      descriptorSetCount = descriptorSetCount_;
+      return *this;
+    }
+
+    DescriptorSetVariableDescriptorCountAllocateInfoEXT & setPDescriptorCounts( const uint32_t* pDescriptorCounts_ )
+    {
+      pDescriptorCounts = pDescriptorCounts_;
+      return *this;
+    }
+
+    operator VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>( this );
+    }
+
+    operator VkDescriptorSetVariableDescriptorCountAllocateInfoEXT &()
+    {
+      return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>( this );
+    }
+
+    bool operator==( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( descriptorSetCount == rhs.descriptorSetCount )
+          && ( pDescriptorCounts == rhs.pDescriptorCounts );
+    }
+
+    bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t descriptorSetCount;
+    const uint32_t* pDescriptorCounts;
+  };
+  static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DescriptorSetVariableDescriptorCountLayoutSupportEXT
+  {
+    operator VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const&() const
+    {
+      return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>( this );
+    }
+
+    operator VkDescriptorSetVariableDescriptorCountLayoutSupportEXT &()
+    {
+      return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>( this );
+    }
+
+    bool operator==( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount );
+    }
+
+    bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t maxVariableDescriptorCount;
+  };
+  static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "struct and wrapper have different size!" );
+
+  struct DescriptorUpdateTemplateEntry
+  {
+    DescriptorUpdateTemplateEntry( uint32_t dstBinding_ = 0,
+                                   uint32_t dstArrayElement_ = 0,
+                                   uint32_t descriptorCount_ = 0,
+                                   DescriptorType descriptorType_ = DescriptorType::eSampler,
+                                   size_t offset_ = 0,
+                                   size_t stride_ = 0 )
+      : dstBinding( dstBinding_ )
+      , dstArrayElement( dstArrayElement_ )
+      , descriptorCount( descriptorCount_ )
+      , descriptorType( descriptorType_ )
+      , offset( offset_ )
+      , stride( stride_ )
+    {}
+
+    DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) );
+    }
+
+    DescriptorUpdateTemplateEntry& operator=( VkDescriptorUpdateTemplateEntry const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) );
+      return *this;
+    }
+
+    DescriptorUpdateTemplateEntry & setDstBinding( uint32_t dstBinding_ )
+    {
+      dstBinding = dstBinding_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateEntry & setDstArrayElement( uint32_t dstArrayElement_ )
+    {
+      dstArrayElement = dstArrayElement_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateEntry & setDescriptorCount( uint32_t descriptorCount_ )
+    {
+      descriptorCount = descriptorCount_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateEntry & setDescriptorType( DescriptorType descriptorType_ )
+    {
+      descriptorType = descriptorType_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateEntry & setOffset( size_t offset_ )
+    {
+      offset = offset_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateEntry & setStride( size_t stride_ )
+    {
+      stride = stride_;
+      return *this;
+    }
+
+    operator VkDescriptorUpdateTemplateEntry const&() const
+    {
+      return *reinterpret_cast<const VkDescriptorUpdateTemplateEntry*>( this );
+    }
+
+    operator VkDescriptorUpdateTemplateEntry &()
+    {
+      return *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>( this );
+    }
+
+    bool operator==( DescriptorUpdateTemplateEntry const& rhs ) const
+    {
+      return ( dstBinding == rhs.dstBinding )
+          && ( dstArrayElement == rhs.dstArrayElement )
+          && ( descriptorCount == rhs.descriptorCount )
+          && ( descriptorType == rhs.descriptorType )
+          && ( offset == rhs.offset )
+          && ( stride == rhs.stride );
+    }
+
+    bool operator!=( DescriptorUpdateTemplateEntry const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t dstBinding;
+    uint32_t dstArrayElement;
+    uint32_t descriptorCount;
+    DescriptorType descriptorType;
+    size_t offset;
+    size_t stride;
+  };
+  static_assert( sizeof( DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), "struct and wrapper have different size!" );
+
+  struct DescriptorUpdateTemplateCreateInfo
+  {
+    DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_ = DescriptorUpdateTemplateCreateFlags(),
+                                        uint32_t descriptorUpdateEntryCount_ = 0,
+                                        const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr,
+                                        DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet,
+                                        DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(),
+                                        PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
+                                        PipelineLayout pipelineLayout_ = PipelineLayout(),
+                                        uint32_t set_ = 0 )
+      : flags( flags_ )
+      , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
+      , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
+      , templateType( templateType_ )
+      , descriptorSetLayout( descriptorSetLayout_ )
+      , pipelineBindPoint( pipelineBindPoint_ )
+      , pipelineLayout( pipelineLayout_ )
+      , set( set_ )
+    {}
+
+    DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
+    }
+
+    DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo & setFlags( DescriptorUpdateTemplateCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo & setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ )
+    {
+      descriptorUpdateEntryCount = descriptorUpdateEntryCount_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo & setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ )
+    {
+      pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo & setTemplateType( DescriptorUpdateTemplateType templateType_ )
+    {
+      templateType = templateType_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo & setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ )
+    {
+      descriptorSetLayout = descriptorSetLayout_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+    {
+      pipelineBindPoint = pipelineBindPoint_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo & setPipelineLayout( PipelineLayout pipelineLayout_ )
+    {
+      pipelineLayout = pipelineLayout_;
+      return *this;
+    }
+
+    DescriptorUpdateTemplateCreateInfo & setSet( uint32_t set_ )
+    {
+      set = set_;
+      return *this;
+    }
+
+    operator VkDescriptorUpdateTemplateCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( this );
+    }
+
+    operator VkDescriptorUpdateTemplateCreateInfo &()
+    {
+      return *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>( this );
+    }
+
+    bool operator==( DescriptorUpdateTemplateCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount )
+          && ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries )
+          && ( templateType == rhs.templateType )
+          && ( descriptorSetLayout == rhs.descriptorSetLayout )
+          && ( pipelineBindPoint == rhs.pipelineBindPoint )
+          && ( pipelineLayout == rhs.pipelineLayout )
+          && ( set == rhs.set );
+    }
+
+    bool operator!=( DescriptorUpdateTemplateCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    DescriptorUpdateTemplateCreateFlags flags;
+    uint32_t descriptorUpdateEntryCount;
+    const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;
+    DescriptorUpdateTemplateType templateType;
+    DescriptorSetLayout descriptorSetLayout;
+    PipelineBindPoint pipelineBindPoint;
+    PipelineLayout pipelineLayout;
+    uint32_t set;
+  };
+  static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" );
+
+  struct DeviceQueueCreateInfo
+  {
+    DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(),
+                           uint32_t queueFamilyIndex_ = 0,
+                           uint32_t queueCount_ = 0,
+                           const float* pQueuePriorities_ = nullptr )
+      : flags( flags_ )
+      , queueFamilyIndex( queueFamilyIndex_ )
+      , queueCount( queueCount_ )
+      , pQueuePriorities( pQueuePriorities_ )
+    {}
+
+    DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
+    }
+
+    DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
+      return *this;
+    }
+
+    DeviceQueueCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceQueueCreateInfo & setFlags( DeviceQueueCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    DeviceQueueCreateInfo & setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
+    {
+      queueFamilyIndex = queueFamilyIndex_;
+      return *this;
+    }
+
+    DeviceQueueCreateInfo & setQueueCount( uint32_t queueCount_ )
+    {
+      queueCount = queueCount_;
+      return *this;
+    }
+
+    DeviceQueueCreateInfo & setPQueuePriorities( const float* pQueuePriorities_ )
+    {
+      pQueuePriorities = pQueuePriorities_;
+      return *this;
+    }
+
+    operator VkDeviceQueueCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkDeviceQueueCreateInfo*>( this );
+    }
+
+    operator VkDeviceQueueCreateInfo &()
+    {
+      return *reinterpret_cast<VkDeviceQueueCreateInfo*>( this );
+    }
+
+    bool operator==( DeviceQueueCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( queueFamilyIndex == rhs.queueFamilyIndex )
+          && ( queueCount == rhs.queueCount )
+          && ( pQueuePriorities == rhs.pQueuePriorities );
+    }
+
+    bool operator!=( DeviceQueueCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceQueueCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    DeviceQueueCreateFlags flags;
+    uint32_t queueFamilyIndex;
+    uint32_t queueCount;
+    const float* pQueuePriorities;
+  };
+  static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceFeatures
+  {
+    PhysicalDeviceFeatures( Bool32 robustBufferAccess_ = 0,
+                            Bool32 fullDrawIndexUint32_ = 0,
+                            Bool32 imageCubeArray_ = 0,
+                            Bool32 independentBlend_ = 0,
+                            Bool32 geometryShader_ = 0,
+                            Bool32 tessellationShader_ = 0,
+                            Bool32 sampleRateShading_ = 0,
+                            Bool32 dualSrcBlend_ = 0,
+                            Bool32 logicOp_ = 0,
+                            Bool32 multiDrawIndirect_ = 0,
+                            Bool32 drawIndirectFirstInstance_ = 0,
+                            Bool32 depthClamp_ = 0,
+                            Bool32 depthBiasClamp_ = 0,
+                            Bool32 fillModeNonSolid_ = 0,
+                            Bool32 depthBounds_ = 0,
+                            Bool32 wideLines_ = 0,
+                            Bool32 largePoints_ = 0,
+                            Bool32 alphaToOne_ = 0,
+                            Bool32 multiViewport_ = 0,
+                            Bool32 samplerAnisotropy_ = 0,
+                            Bool32 textureCompressionETC2_ = 0,
+                            Bool32 textureCompressionASTC_LDR_ = 0,
+                            Bool32 textureCompressionBC_ = 0,
+                            Bool32 occlusionQueryPrecise_ = 0,
+                            Bool32 pipelineStatisticsQuery_ = 0,
+                            Bool32 vertexPipelineStoresAndAtomics_ = 0,
+                            Bool32 fragmentStoresAndAtomics_ = 0,
+                            Bool32 shaderTessellationAndGeometryPointSize_ = 0,
+                            Bool32 shaderImageGatherExtended_ = 0,
+                            Bool32 shaderStorageImageExtendedFormats_ = 0,
+                            Bool32 shaderStorageImageMultisample_ = 0,
+                            Bool32 shaderStorageImageReadWithoutFormat_ = 0,
+                            Bool32 shaderStorageImageWriteWithoutFormat_ = 0,
+                            Bool32 shaderUniformBufferArrayDynamicIndexing_ = 0,
+                            Bool32 shaderSampledImageArrayDynamicIndexing_ = 0,
+                            Bool32 shaderStorageBufferArrayDynamicIndexing_ = 0,
+                            Bool32 shaderStorageImageArrayDynamicIndexing_ = 0,
+                            Bool32 shaderClipDistance_ = 0,
+                            Bool32 shaderCullDistance_ = 0,
+                            Bool32 shaderFloat64_ = 0,
+                            Bool32 shaderInt64_ = 0,
+                            Bool32 shaderInt16_ = 0,
+                            Bool32 shaderResourceResidency_ = 0,
+                            Bool32 shaderResourceMinLod_ = 0,
+                            Bool32 sparseBinding_ = 0,
+                            Bool32 sparseResidencyBuffer_ = 0,
+                            Bool32 sparseResidencyImage2D_ = 0,
+                            Bool32 sparseResidencyImage3D_ = 0,
+                            Bool32 sparseResidency2Samples_ = 0,
+                            Bool32 sparseResidency4Samples_ = 0,
+                            Bool32 sparseResidency8Samples_ = 0,
+                            Bool32 sparseResidency16Samples_ = 0,
+                            Bool32 sparseResidencyAliased_ = 0,
+                            Bool32 variableMultisampleRate_ = 0,
+                            Bool32 inheritedQueries_ = 0 )
+      : robustBufferAccess( robustBufferAccess_ )
+      , fullDrawIndexUint32( fullDrawIndexUint32_ )
+      , imageCubeArray( imageCubeArray_ )
+      , independentBlend( independentBlend_ )
+      , geometryShader( geometryShader_ )
+      , tessellationShader( tessellationShader_ )
+      , sampleRateShading( sampleRateShading_ )
+      , dualSrcBlend( dualSrcBlend_ )
+      , logicOp( logicOp_ )
+      , multiDrawIndirect( multiDrawIndirect_ )
+      , drawIndirectFirstInstance( drawIndirectFirstInstance_ )
+      , depthClamp( depthClamp_ )
+      , depthBiasClamp( depthBiasClamp_ )
+      , fillModeNonSolid( fillModeNonSolid_ )
+      , depthBounds( depthBounds_ )
+      , wideLines( wideLines_ )
+      , largePoints( largePoints_ )
+      , alphaToOne( alphaToOne_ )
+      , multiViewport( multiViewport_ )
+      , samplerAnisotropy( samplerAnisotropy_ )
+      , textureCompressionETC2( textureCompressionETC2_ )
+      , textureCompressionASTC_LDR( textureCompressionASTC_LDR_ )
+      , textureCompressionBC( textureCompressionBC_ )
+      , occlusionQueryPrecise( occlusionQueryPrecise_ )
+      , pipelineStatisticsQuery( pipelineStatisticsQuery_ )
+      , vertexPipelineStoresAndAtomics( vertexPipelineStoresAndAtomics_ )
+      , fragmentStoresAndAtomics( fragmentStoresAndAtomics_ )
+      , shaderTessellationAndGeometryPointSize( shaderTessellationAndGeometryPointSize_ )
+      , shaderImageGatherExtended( shaderImageGatherExtended_ )
+      , shaderStorageImageExtendedFormats( shaderStorageImageExtendedFormats_ )
+      , shaderStorageImageMultisample( shaderStorageImageMultisample_ )
+      , shaderStorageImageReadWithoutFormat( shaderStorageImageReadWithoutFormat_ )
+      , shaderStorageImageWriteWithoutFormat( shaderStorageImageWriteWithoutFormat_ )
+      , shaderUniformBufferArrayDynamicIndexing( shaderUniformBufferArrayDynamicIndexing_ )
+      , shaderSampledImageArrayDynamicIndexing( shaderSampledImageArrayDynamicIndexing_ )
+      , shaderStorageBufferArrayDynamicIndexing( shaderStorageBufferArrayDynamicIndexing_ )
+      , shaderStorageImageArrayDynamicIndexing( shaderStorageImageArrayDynamicIndexing_ )
+      , shaderClipDistance( shaderClipDistance_ )
+      , shaderCullDistance( shaderCullDistance_ )
+      , shaderFloat64( shaderFloat64_ )
+      , shaderInt64( shaderInt64_ )
+      , shaderInt16( shaderInt16_ )
+      , shaderResourceResidency( shaderResourceResidency_ )
+      , shaderResourceMinLod( shaderResourceMinLod_ )
+      , sparseBinding( sparseBinding_ )
+      , sparseResidencyBuffer( sparseResidencyBuffer_ )
+      , sparseResidencyImage2D( sparseResidencyImage2D_ )
+      , sparseResidencyImage3D( sparseResidencyImage3D_ )
+      , sparseResidency2Samples( sparseResidency2Samples_ )
+      , sparseResidency4Samples( sparseResidency4Samples_ )
+      , sparseResidency8Samples( sparseResidency8Samples_ )
+      , sparseResidency16Samples( sparseResidency16Samples_ )
+      , sparseResidencyAliased( sparseResidencyAliased_ )
+      , variableMultisampleRate( variableMultisampleRate_ )
+      , inheritedQueries( inheritedQueries_ )
+    {}
+
+    PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
+    }
+
+    PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setRobustBufferAccess( Bool32 robustBufferAccess_ )
+    {
+      robustBufferAccess = robustBufferAccess_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ )
+    {
+      fullDrawIndexUint32 = fullDrawIndexUint32_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setImageCubeArray( Bool32 imageCubeArray_ )
+    {
+      imageCubeArray = imageCubeArray_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setIndependentBlend( Bool32 independentBlend_ )
+    {
+      independentBlend = independentBlend_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setGeometryShader( Bool32 geometryShader_ )
+    {
+      geometryShader = geometryShader_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setTessellationShader( Bool32 tessellationShader_ )
+    {
+      tessellationShader = tessellationShader_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setSampleRateShading( Bool32 sampleRateShading_ )
+    {
+      sampleRateShading = sampleRateShading_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setDualSrcBlend( Bool32 dualSrcBlend_ )
+    {
+      dualSrcBlend = dualSrcBlend_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setLogicOp( Bool32 logicOp_ )
+    {
+      logicOp = logicOp_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setMultiDrawIndirect( Bool32 multiDrawIndirect_ )
+    {
+      multiDrawIndirect = multiDrawIndirect_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ )
+    {
+      drawIndirectFirstInstance = drawIndirectFirstInstance_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setDepthClamp( Bool32 depthClamp_ )
+    {
+      depthClamp = depthClamp_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setDepthBiasClamp( Bool32 depthBiasClamp_ )
+    {
+      depthBiasClamp = depthBiasClamp_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setFillModeNonSolid( Bool32 fillModeNonSolid_ )
+    {
+      fillModeNonSolid = fillModeNonSolid_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setDepthBounds( Bool32 depthBounds_ )
+    {
+      depthBounds = depthBounds_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setWideLines( Bool32 wideLines_ )
+    {
+      wideLines = wideLines_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setLargePoints( Bool32 largePoints_ )
+    {
+      largePoints = largePoints_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setAlphaToOne( Bool32 alphaToOne_ )
+    {
+      alphaToOne = alphaToOne_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setMultiViewport( Bool32 multiViewport_ )
+    {
+      multiViewport = multiViewport_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setSamplerAnisotropy( Bool32 samplerAnisotropy_ )
+    {
+      samplerAnisotropy = samplerAnisotropy_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setTextureCompressionETC2( Bool32 textureCompressionETC2_ )
+    {
+      textureCompressionETC2 = textureCompressionETC2_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ )
+    {
+      textureCompressionASTC_LDR = textureCompressionASTC_LDR_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setTextureCompressionBC( Bool32 textureCompressionBC_ )
+    {
+      textureCompressionBC = textureCompressionBC_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ )
+    {
+      occlusionQueryPrecise = occlusionQueryPrecise_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ )
+    {
+      pipelineStatisticsQuery = pipelineStatisticsQuery_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ )
+    {
+      vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ )
+    {
+      fragmentStoresAndAtomics = fragmentStoresAndAtomics_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ )
+    {
+      shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ )
+    {
+      shaderImageGatherExtended = shaderImageGatherExtended_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ )
+    {
+      shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ )
+    {
+      shaderStorageImageMultisample = shaderStorageImageMultisample_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ )
+    {
+      shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ )
+    {
+      shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ )
+    {
+      shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ )
+    {
+      shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ )
+    {
+      shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ )
+    {
+      shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderClipDistance( Bool32 shaderClipDistance_ )
+    {
+      shaderClipDistance = shaderClipDistance_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderCullDistance( Bool32 shaderCullDistance_ )
+    {
+      shaderCullDistance = shaderCullDistance_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderFloat64( Bool32 shaderFloat64_ )
+    {
+      shaderFloat64 = shaderFloat64_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderInt64( Bool32 shaderInt64_ )
+    {
+      shaderInt64 = shaderInt64_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderInt16( Bool32 shaderInt16_ )
+    {
+      shaderInt16 = shaderInt16_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderResourceResidency( Bool32 shaderResourceResidency_ )
+    {
+      shaderResourceResidency = shaderResourceResidency_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setShaderResourceMinLod( Bool32 shaderResourceMinLod_ )
+    {
+      shaderResourceMinLod = shaderResourceMinLod_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setSparseBinding( Bool32 sparseBinding_ )
+    {
+      sparseBinding = sparseBinding_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ )
+    {
+      sparseResidencyBuffer = sparseResidencyBuffer_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ )
+    {
+      sparseResidencyImage2D = sparseResidencyImage2D_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ )
+    {
+      sparseResidencyImage3D = sparseResidencyImage3D_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setSparseResidency2Samples( Bool32 sparseResidency2Samples_ )
+    {
+      sparseResidency2Samples = sparseResidency2Samples_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setSparseResidency4Samples( Bool32 sparseResidency4Samples_ )
+    {
+      sparseResidency4Samples = sparseResidency4Samples_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setSparseResidency8Samples( Bool32 sparseResidency8Samples_ )
+    {
+      sparseResidency8Samples = sparseResidency8Samples_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setSparseResidency16Samples( Bool32 sparseResidency16Samples_ )
+    {
+      sparseResidency16Samples = sparseResidency16Samples_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setSparseResidencyAliased( Bool32 sparseResidencyAliased_ )
+    {
+      sparseResidencyAliased = sparseResidencyAliased_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setVariableMultisampleRate( Bool32 variableMultisampleRate_ )
+    {
+      variableMultisampleRate = variableMultisampleRate_;
+      return *this;
+    }
+
+    PhysicalDeviceFeatures & setInheritedQueries( Bool32 inheritedQueries_ )
+    {
+      inheritedQueries = inheritedQueries_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceFeatures const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceFeatures*>( this );
+    }
+
+    operator VkPhysicalDeviceFeatures &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceFeatures*>( this );
+    }
+
+    bool operator==( PhysicalDeviceFeatures const& rhs ) const
+    {
+      return ( robustBufferAccess == rhs.robustBufferAccess )
+          && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 )
+          && ( imageCubeArray == rhs.imageCubeArray )
+          && ( independentBlend == rhs.independentBlend )
+          && ( geometryShader == rhs.geometryShader )
+          && ( tessellationShader == rhs.tessellationShader )
+          && ( sampleRateShading == rhs.sampleRateShading )
+          && ( dualSrcBlend == rhs.dualSrcBlend )
+          && ( logicOp == rhs.logicOp )
+          && ( multiDrawIndirect == rhs.multiDrawIndirect )
+          && ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance )
+          && ( depthClamp == rhs.depthClamp )
+          && ( depthBiasClamp == rhs.depthBiasClamp )
+          && ( fillModeNonSolid == rhs.fillModeNonSolid )
+          && ( depthBounds == rhs.depthBounds )
+          && ( wideLines == rhs.wideLines )
+          && ( largePoints == rhs.largePoints )
+          && ( alphaToOne == rhs.alphaToOne )
+          && ( multiViewport == rhs.multiViewport )
+          && ( samplerAnisotropy == rhs.samplerAnisotropy )
+          && ( textureCompressionETC2 == rhs.textureCompressionETC2 )
+          && ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR )
+          && ( textureCompressionBC == rhs.textureCompressionBC )
+          && ( occlusionQueryPrecise == rhs.occlusionQueryPrecise )
+          && ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery )
+          && ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics )
+          && ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics )
+          && ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize )
+          && ( shaderImageGatherExtended == rhs.shaderImageGatherExtended )
+          && ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats )
+          && ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample )
+          && ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat )
+          && ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat )
+          && ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing )
+          && ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing )
+          && ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing )
+          && ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing )
+          && ( shaderClipDistance == rhs.shaderClipDistance )
+          && ( shaderCullDistance == rhs.shaderCullDistance )
+          && ( shaderFloat64 == rhs.shaderFloat64 )
+          && ( shaderInt64 == rhs.shaderInt64 )
+          && ( shaderInt16 == rhs.shaderInt16 )
+          && ( shaderResourceResidency == rhs.shaderResourceResidency )
+          && ( shaderResourceMinLod == rhs.shaderResourceMinLod )
+          && ( sparseBinding == rhs.sparseBinding )
+          && ( sparseResidencyBuffer == rhs.sparseResidencyBuffer )
+          && ( sparseResidencyImage2D == rhs.sparseResidencyImage2D )
+          && ( sparseResidencyImage3D == rhs.sparseResidencyImage3D )
+          && ( sparseResidency2Samples == rhs.sparseResidency2Samples )
+          && ( sparseResidency4Samples == rhs.sparseResidency4Samples )
+          && ( sparseResidency8Samples == rhs.sparseResidency8Samples )
+          && ( sparseResidency16Samples == rhs.sparseResidency16Samples )
+          && ( sparseResidencyAliased == rhs.sparseResidencyAliased )
+          && ( variableMultisampleRate == rhs.variableMultisampleRate )
+          && ( inheritedQueries == rhs.inheritedQueries );
+    }
+
+    bool operator!=( PhysicalDeviceFeatures const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    Bool32 robustBufferAccess;
+    Bool32 fullDrawIndexUint32;
+    Bool32 imageCubeArray;
+    Bool32 independentBlend;
+    Bool32 geometryShader;
+    Bool32 tessellationShader;
+    Bool32 sampleRateShading;
+    Bool32 dualSrcBlend;
+    Bool32 logicOp;
+    Bool32 multiDrawIndirect;
+    Bool32 drawIndirectFirstInstance;
+    Bool32 depthClamp;
+    Bool32 depthBiasClamp;
+    Bool32 fillModeNonSolid;
+    Bool32 depthBounds;
+    Bool32 wideLines;
+    Bool32 largePoints;
+    Bool32 alphaToOne;
+    Bool32 multiViewport;
+    Bool32 samplerAnisotropy;
+    Bool32 textureCompressionETC2;
+    Bool32 textureCompressionASTC_LDR;
+    Bool32 textureCompressionBC;
+    Bool32 occlusionQueryPrecise;
+    Bool32 pipelineStatisticsQuery;
+    Bool32 vertexPipelineStoresAndAtomics;
+    Bool32 fragmentStoresAndAtomics;
+    Bool32 shaderTessellationAndGeometryPointSize;
+    Bool32 shaderImageGatherExtended;
+    Bool32 shaderStorageImageExtendedFormats;
+    Bool32 shaderStorageImageMultisample;
+    Bool32 shaderStorageImageReadWithoutFormat;
+    Bool32 shaderStorageImageWriteWithoutFormat;
+    Bool32 shaderUniformBufferArrayDynamicIndexing;
+    Bool32 shaderSampledImageArrayDynamicIndexing;
+    Bool32 shaderStorageBufferArrayDynamicIndexing;
+    Bool32 shaderStorageImageArrayDynamicIndexing;
+    Bool32 shaderClipDistance;
+    Bool32 shaderCullDistance;
+    Bool32 shaderFloat64;
+    Bool32 shaderInt64;
+    Bool32 shaderInt16;
+    Bool32 shaderResourceResidency;
+    Bool32 shaderResourceMinLod;
+    Bool32 sparseBinding;
+    Bool32 sparseResidencyBuffer;
+    Bool32 sparseResidencyImage2D;
+    Bool32 sparseResidencyImage3D;
+    Bool32 sparseResidency2Samples;
+    Bool32 sparseResidency4Samples;
+    Bool32 sparseResidency8Samples;
+    Bool32 sparseResidency16Samples;
+    Bool32 sparseResidencyAliased;
+    Bool32 variableMultisampleRate;
+    Bool32 inheritedQueries;
+  };
+  static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" );
+
+  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 )
+      : flags( flags_ )
+      , queueCreateInfoCount( queueCreateInfoCount_ )
+      , pQueueCreateInfos( pQueueCreateInfos_ )
+      , enabledLayerCount( enabledLayerCount_ )
+      , ppEnabledLayerNames( ppEnabledLayerNames_ )
+      , enabledExtensionCount( enabledExtensionCount_ )
+      , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
+      , pEnabledFeatures( pEnabledFeatures_ )
+    {}
+
+    DeviceCreateInfo( VkDeviceCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
+    }
+
+    DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
+      return *this;
+    }
+
+    DeviceCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceCreateInfo & setFlags( DeviceCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    DeviceCreateInfo & setQueueCreateInfoCount( uint32_t queueCreateInfoCount_ )
+    {
+      queueCreateInfoCount = queueCreateInfoCount_;
+      return *this;
+    }
+
+    DeviceCreateInfo & setPQueueCreateInfos( const DeviceQueueCreateInfo* pQueueCreateInfos_ )
+    {
+      pQueueCreateInfos = pQueueCreateInfos_;
+      return *this;
+    }
+
+    DeviceCreateInfo & setEnabledLayerCount( uint32_t enabledLayerCount_ )
+    {
+      enabledLayerCount = enabledLayerCount_;
+      return *this;
+    }
+
+    DeviceCreateInfo & setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ )
+    {
+      ppEnabledLayerNames = ppEnabledLayerNames_;
+      return *this;
+    }
+
+    DeviceCreateInfo & setEnabledExtensionCount( uint32_t enabledExtensionCount_ )
+    {
+      enabledExtensionCount = enabledExtensionCount_;
+      return *this;
+    }
+
+    DeviceCreateInfo & setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ )
+    {
+      ppEnabledExtensionNames = ppEnabledExtensionNames_;
+      return *this;
+    }
+
+    DeviceCreateInfo & setPEnabledFeatures( const PhysicalDeviceFeatures* pEnabledFeatures_ )
+    {
+      pEnabledFeatures = pEnabledFeatures_;
+      return *this;
+    }
+
+    operator VkDeviceCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkDeviceCreateInfo*>( this );
+    }
+
+    operator VkDeviceCreateInfo &()
+    {
+      return *reinterpret_cast<VkDeviceCreateInfo*>( this );
+    }
+
+    bool operator==( DeviceCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( queueCreateInfoCount == rhs.queueCreateInfoCount )
+          && ( pQueueCreateInfos == rhs.pQueueCreateInfos )
+          && ( enabledLayerCount == rhs.enabledLayerCount )
+          && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames )
+          && ( enabledExtensionCount == rhs.enabledExtensionCount )
+          && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames )
+          && ( pEnabledFeatures == rhs.pEnabledFeatures );
+    }
+
+    bool operator!=( DeviceCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    DeviceCreateFlags flags;
+    uint32_t queueCreateInfoCount;
+    const DeviceQueueCreateInfo* pQueueCreateInfos;
+    uint32_t enabledLayerCount;
+    const char* const* ppEnabledLayerNames;
+    uint32_t enabledExtensionCount;
+    const char* const* ppEnabledExtensionNames;
+    const PhysicalDeviceFeatures* pEnabledFeatures;
+  };
+  static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" );
+
+  struct DeviceEventInfoEXT
+  {
+    DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug )
+      : deviceEvent( deviceEvent_ )
+    {}
+
+    DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
+    }
+
+    DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
+      return *this;
+    }
+
+    DeviceEventInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceEventInfoEXT & setDeviceEvent( DeviceEventTypeEXT deviceEvent_ )
+    {
+      deviceEvent = deviceEvent_;
+      return *this;
+    }
+
+    operator VkDeviceEventInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDeviceEventInfoEXT*>( this );
+    }
+
+    operator VkDeviceEventInfoEXT &()
+    {
+      return *reinterpret_cast<VkDeviceEventInfoEXT*>( this );
+    }
+
+    bool operator==( DeviceEventInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( deviceEvent == rhs.deviceEvent );
+    }
+
+    bool operator!=( DeviceEventInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceEventInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    DeviceEventTypeEXT deviceEvent;
+  };
+  static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DeviceGeneratedCommandsFeaturesNVX
+  {
+    DeviceGeneratedCommandsFeaturesNVX( Bool32 computeBindingPointSupport_ = 0 )
+      : computeBindingPointSupport( computeBindingPointSupport_ )
+    {}
+
+    DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) );
+    }
+
+    DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) );
+      return *this;
+    }
+
+    DeviceGeneratedCommandsFeaturesNVX & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceGeneratedCommandsFeaturesNVX & setComputeBindingPointSupport( Bool32 computeBindingPointSupport_ )
+    {
+      computeBindingPointSupport = computeBindingPointSupport_;
+      return *this;
+    }
+
+    operator VkDeviceGeneratedCommandsFeaturesNVX const&() const
+    {
+      return *reinterpret_cast<const VkDeviceGeneratedCommandsFeaturesNVX*>( this );
+    }
+
+    operator VkDeviceGeneratedCommandsFeaturesNVX &()
+    {
+      return *reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( this );
+    }
+
+    bool operator==( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( computeBindingPointSupport == rhs.computeBindingPointSupport );
+    }
+
+    bool operator!=( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX;
+
+  public:
+    const void* pNext = nullptr;
+    Bool32 computeBindingPointSupport;
+  };
+  static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" );
+
+  struct DeviceGeneratedCommandsLimitsNVX
+  {
+    DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0,
+                                      uint32_t maxObjectEntryCounts_ = 0,
+                                      uint32_t minSequenceCountBufferOffsetAlignment_ = 0,
+                                      uint32_t minSequenceIndexBufferOffsetAlignment_ = 0,
+                                      uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 )
+      : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
+      , maxObjectEntryCounts( maxObjectEntryCounts_ )
+      , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ )
+      , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ )
+      , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ )
+    {}
+
+    DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) );
+    }
+
+    DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) );
+      return *this;
+    }
+
+    DeviceGeneratedCommandsLimitsNVX & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceGeneratedCommandsLimitsNVX & setMaxIndirectCommandsLayoutTokenCount( uint32_t maxIndirectCommandsLayoutTokenCount_ )
+    {
+      maxIndirectCommandsLayoutTokenCount = maxIndirectCommandsLayoutTokenCount_;
+      return *this;
+    }
+
+    DeviceGeneratedCommandsLimitsNVX & setMaxObjectEntryCounts( uint32_t maxObjectEntryCounts_ )
+    {
+      maxObjectEntryCounts = maxObjectEntryCounts_;
+      return *this;
+    }
+
+    DeviceGeneratedCommandsLimitsNVX & setMinSequenceCountBufferOffsetAlignment( uint32_t minSequenceCountBufferOffsetAlignment_ )
+    {
+      minSequenceCountBufferOffsetAlignment = minSequenceCountBufferOffsetAlignment_;
+      return *this;
+    }
+
+    DeviceGeneratedCommandsLimitsNVX & setMinSequenceIndexBufferOffsetAlignment( uint32_t minSequenceIndexBufferOffsetAlignment_ )
+    {
+      minSequenceIndexBufferOffsetAlignment = minSequenceIndexBufferOffsetAlignment_;
+      return *this;
+    }
+
+    DeviceGeneratedCommandsLimitsNVX & setMinCommandsTokenBufferOffsetAlignment( uint32_t minCommandsTokenBufferOffsetAlignment_ )
+    {
+      minCommandsTokenBufferOffsetAlignment = minCommandsTokenBufferOffsetAlignment_;
+      return *this;
+    }
+
+    operator VkDeviceGeneratedCommandsLimitsNVX const&() const
+    {
+      return *reinterpret_cast<const VkDeviceGeneratedCommandsLimitsNVX*>( this );
+    }
+
+    operator VkDeviceGeneratedCommandsLimitsNVX &()
+    {
+      return *reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( this );
+    }
+
+    bool operator==( DeviceGeneratedCommandsLimitsNVX const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( maxIndirectCommandsLayoutTokenCount == rhs.maxIndirectCommandsLayoutTokenCount )
+          && ( maxObjectEntryCounts == rhs.maxObjectEntryCounts )
+          && ( minSequenceCountBufferOffsetAlignment == rhs.minSequenceCountBufferOffsetAlignment )
+          && ( minSequenceIndexBufferOffsetAlignment == rhs.minSequenceIndexBufferOffsetAlignment )
+          && ( minCommandsTokenBufferOffsetAlignment == rhs.minCommandsTokenBufferOffsetAlignment );
+    }
+
+    bool operator!=( DeviceGeneratedCommandsLimitsNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t maxIndirectCommandsLayoutTokenCount;
+    uint32_t maxObjectEntryCounts;
+    uint32_t minSequenceCountBufferOffsetAlignment;
+    uint32_t minSequenceIndexBufferOffsetAlignment;
+    uint32_t minCommandsTokenBufferOffsetAlignment;
+  };
+  static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "struct and wrapper have different size!" );
+
+  struct DeviceGroupBindSparseInfo
+  {
+    DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0,
+                               uint32_t memoryDeviceIndex_ = 0 )
+      : resourceDeviceIndex( resourceDeviceIndex_ )
+      , memoryDeviceIndex( memoryDeviceIndex_ )
+    {}
+
+    DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfo ) );
+    }
+
+    DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfo ) );
+      return *this;
+    }
+
+    DeviceGroupBindSparseInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceGroupBindSparseInfo & setResourceDeviceIndex( uint32_t resourceDeviceIndex_ )
+    {
+      resourceDeviceIndex = resourceDeviceIndex_;
+      return *this;
+    }
+
+    DeviceGroupBindSparseInfo & setMemoryDeviceIndex( uint32_t memoryDeviceIndex_ )
+    {
+      memoryDeviceIndex = memoryDeviceIndex_;
+      return *this;
+    }
+
+    operator VkDeviceGroupBindSparseInfo const&() const
+    {
+      return *reinterpret_cast<const VkDeviceGroupBindSparseInfo*>( this );
+    }
+
+    operator VkDeviceGroupBindSparseInfo &()
+    {
+      return *reinterpret_cast<VkDeviceGroupBindSparseInfo*>( this );
+    }
+
+    bool operator==( DeviceGroupBindSparseInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( resourceDeviceIndex == rhs.resourceDeviceIndex )
+          && ( memoryDeviceIndex == rhs.memoryDeviceIndex );
+    }
+
+    bool operator!=( DeviceGroupBindSparseInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceGroupBindSparseInfo;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t resourceDeviceIndex;
+    uint32_t memoryDeviceIndex;
+  };
+  static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "struct and wrapper have different size!" );
+
+  struct DeviceGroupCommandBufferBeginInfo
+  {
+    DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 )
+      : deviceMask( deviceMask_ )
+    {}
+
+    DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfo ) );
+    }
+
+    DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfo ) );
+      return *this;
+    }
+
+    DeviceGroupCommandBufferBeginInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceGroupCommandBufferBeginInfo & setDeviceMask( uint32_t deviceMask_ )
+    {
+      deviceMask = deviceMask_;
+      return *this;
+    }
+
+    operator VkDeviceGroupCommandBufferBeginInfo const&() const
+    {
+      return *reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>( this );
+    }
+
+    operator VkDeviceGroupCommandBufferBeginInfo &()
+    {
+      return *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>( this );
+    }
+
+    bool operator==( DeviceGroupCommandBufferBeginInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( deviceMask == rhs.deviceMask );
+    }
+
+    bool operator!=( DeviceGroupCommandBufferBeginInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t deviceMask;
+  };
+  static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "struct and wrapper have different size!" );
+
+  struct DeviceGroupDeviceCreateInfo
+  {
+    DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0,
+                                 const PhysicalDevice* pPhysicalDevices_ = nullptr )
+      : physicalDeviceCount( physicalDeviceCount_ )
+      , pPhysicalDevices( pPhysicalDevices_ )
+    {}
+
+    DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfo ) );
+    }
+
+    DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfo ) );
+      return *this;
+    }
+
+    DeviceGroupDeviceCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceGroupDeviceCreateInfo & setPhysicalDeviceCount( uint32_t physicalDeviceCount_ )
+    {
+      physicalDeviceCount = physicalDeviceCount_;
+      return *this;
+    }
+
+    DeviceGroupDeviceCreateInfo & setPPhysicalDevices( const PhysicalDevice* pPhysicalDevices_ )
+    {
+      pPhysicalDevices = pPhysicalDevices_;
+      return *this;
+    }
+
+    operator VkDeviceGroupDeviceCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>( this );
+    }
+
+    operator VkDeviceGroupDeviceCreateInfo &()
+    {
+      return *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>( this );
+    }
+
+    bool operator==( DeviceGroupDeviceCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( physicalDeviceCount == rhs.physicalDeviceCount )
+          && ( pPhysicalDevices == rhs.pPhysicalDevices );
+    }
+
+    bool operator!=( DeviceGroupDeviceCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t physicalDeviceCount;
+    const PhysicalDevice* pPhysicalDevices;
+  };
+  static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "struct and wrapper have different size!" );
+
+  struct DeviceGroupPresentCapabilitiesKHR
+  {
+    operator VkDeviceGroupPresentCapabilitiesKHR const&() const
+    {
+      return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR*>( this );
+    }
+
+    operator VkDeviceGroupPresentCapabilitiesKHR &()
+    {
+      return *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>( this );
+    }
+
+    bool operator==( DeviceGroupPresentCapabilitiesKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( memcmp( presentMask, rhs.presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof( uint32_t ) ) == 0 )
+          && ( modes == rhs.modes );
+    }
+
+    bool operator!=( DeviceGroupPresentCapabilitiesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
+    DeviceGroupPresentModeFlagsKHR modes;
+  };
+  static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "struct and wrapper have different size!" );
+
+  struct DeviceGroupPresentInfoKHR
+  {
+    DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0,
+                               const uint32_t* pDeviceMasks_ = nullptr,
+                               DeviceGroupPresentModeFlagBitsKHR mode_ = DeviceGroupPresentModeFlagBitsKHR::eLocal )
+      : swapchainCount( swapchainCount_ )
+      , pDeviceMasks( pDeviceMasks_ )
+      , mode( mode_ )
+    {}
+
+    DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) );
+    }
+
+    DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) );
+      return *this;
+    }
+
+    DeviceGroupPresentInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceGroupPresentInfoKHR & setSwapchainCount( uint32_t swapchainCount_ )
+    {
+      swapchainCount = swapchainCount_;
+      return *this;
+    }
+
+    DeviceGroupPresentInfoKHR & setPDeviceMasks( const uint32_t* pDeviceMasks_ )
+    {
+      pDeviceMasks = pDeviceMasks_;
+      return *this;
+    }
+
+    DeviceGroupPresentInfoKHR & setMode( DeviceGroupPresentModeFlagBitsKHR mode_ )
+    {
+      mode = mode_;
+      return *this;
+    }
+
+    operator VkDeviceGroupPresentInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>( this );
+    }
+
+    operator VkDeviceGroupPresentInfoKHR &()
+    {
+      return *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>( this );
+    }
+
+    bool operator==( DeviceGroupPresentInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( swapchainCount == rhs.swapchainCount )
+          && ( pDeviceMasks == rhs.pDeviceMasks )
+          && ( mode == rhs.mode );
+    }
+
+    bool operator!=( DeviceGroupPresentInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceGroupPresentInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t swapchainCount;
+    const uint32_t* pDeviceMasks;
+    DeviceGroupPresentModeFlagBitsKHR mode;
+  };
+  static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "struct and wrapper have different size!" );
+
+  struct DeviceGroupRenderPassBeginInfo
+  {
+    DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0,
+                                    uint32_t deviceRenderAreaCount_ = 0,
+                                    const Rect2D* pDeviceRenderAreas_ = nullptr )
+      : deviceMask( deviceMask_ )
+      , deviceRenderAreaCount( deviceRenderAreaCount_ )
+      , pDeviceRenderAreas( pDeviceRenderAreas_ )
+    {}
+
+    DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfo ) );
+    }
+
+    DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfo ) );
+      return *this;
+    }
+
+    DeviceGroupRenderPassBeginInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceGroupRenderPassBeginInfo & setDeviceMask( uint32_t deviceMask_ )
+    {
+      deviceMask = deviceMask_;
+      return *this;
+    }
+
+    DeviceGroupRenderPassBeginInfo & setDeviceRenderAreaCount( uint32_t deviceRenderAreaCount_ )
+    {
+      deviceRenderAreaCount = deviceRenderAreaCount_;
+      return *this;
+    }
+
+    DeviceGroupRenderPassBeginInfo & setPDeviceRenderAreas( const Rect2D* pDeviceRenderAreas_ )
+    {
+      pDeviceRenderAreas = pDeviceRenderAreas_;
+      return *this;
+    }
+
+    operator VkDeviceGroupRenderPassBeginInfo const&() const
+    {
+      return *reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>( this );
+    }
+
+    operator VkDeviceGroupRenderPassBeginInfo &()
+    {
+      return *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>( this );
+    }
+
+    bool operator==( DeviceGroupRenderPassBeginInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( deviceMask == rhs.deviceMask )
+          && ( deviceRenderAreaCount == rhs.deviceRenderAreaCount )
+          && ( pDeviceRenderAreas == rhs.pDeviceRenderAreas );
+    }
+
+    bool operator!=( DeviceGroupRenderPassBeginInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t deviceMask;
+    uint32_t deviceRenderAreaCount;
+    const Rect2D* pDeviceRenderAreas;
+  };
+  static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "struct and wrapper have different size!" );
+
+  struct DeviceGroupSubmitInfo
+  {
+    DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0,
+                           const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr,
+                           uint32_t commandBufferCount_ = 0,
+                           const uint32_t* pCommandBufferDeviceMasks_ = nullptr,
+                           uint32_t signalSemaphoreCount_ = 0,
+                           const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr )
+      : waitSemaphoreCount( waitSemaphoreCount_ )
+      , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ )
+      , commandBufferCount( commandBufferCount_ )
+      , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ )
+      , signalSemaphoreCount( signalSemaphoreCount_ )
+      , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ )
+    {}
+
+    DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfo ) );
+    }
+
+    DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfo ) );
+      return *this;
+    }
+
+    DeviceGroupSubmitInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceGroupSubmitInfo & setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
+    {
+      waitSemaphoreCount = waitSemaphoreCount_;
+      return *this;
+    }
+
+    DeviceGroupSubmitInfo & setPWaitSemaphoreDeviceIndices( const uint32_t* pWaitSemaphoreDeviceIndices_ )
+    {
+      pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices_;
+      return *this;
+    }
+
+    DeviceGroupSubmitInfo & setCommandBufferCount( uint32_t commandBufferCount_ )
+    {
+      commandBufferCount = commandBufferCount_;
+      return *this;
+    }
+
+    DeviceGroupSubmitInfo & setPCommandBufferDeviceMasks( const uint32_t* pCommandBufferDeviceMasks_ )
+    {
+      pCommandBufferDeviceMasks = pCommandBufferDeviceMasks_;
+      return *this;
+    }
+
+    DeviceGroupSubmitInfo & setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
+    {
+      signalSemaphoreCount = signalSemaphoreCount_;
+      return *this;
+    }
+
+    DeviceGroupSubmitInfo & setPSignalSemaphoreDeviceIndices( const uint32_t* pSignalSemaphoreDeviceIndices_ )
+    {
+      pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices_;
+      return *this;
+    }
+
+    operator VkDeviceGroupSubmitInfo const&() const
+    {
+      return *reinterpret_cast<const VkDeviceGroupSubmitInfo*>( this );
+    }
+
+    operator VkDeviceGroupSubmitInfo &()
+    {
+      return *reinterpret_cast<VkDeviceGroupSubmitInfo*>( this );
+    }
+
+    bool operator==( DeviceGroupSubmitInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
+          && ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices )
+          && ( commandBufferCount == rhs.commandBufferCount )
+          && ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks )
+          && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
+          && ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices );
+    }
+
+    bool operator!=( DeviceGroupSubmitInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceGroupSubmitInfo;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t waitSemaphoreCount;
+    const uint32_t* pWaitSemaphoreDeviceIndices;
+    uint32_t commandBufferCount;
+    const uint32_t* pCommandBufferDeviceMasks;
+    uint32_t signalSemaphoreCount;
+    const uint32_t* pSignalSemaphoreDeviceIndices;
+  };
+  static_assert( sizeof( DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), "struct and wrapper have different size!" );
+
+  struct DeviceGroupSwapchainCreateInfoKHR
+  {
+    DeviceGroupSwapchainCreateInfoKHR( DeviceGroupPresentModeFlagsKHR modes_ = DeviceGroupPresentModeFlagsKHR() )
+      : modes( modes_ )
+    {}
+
+    DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) );
+    }
+
+    DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) );
+      return *this;
+    }
+
+    DeviceGroupSwapchainCreateInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceGroupSwapchainCreateInfoKHR & setModes( DeviceGroupPresentModeFlagsKHR modes_ )
+    {
+      modes = modes_;
+      return *this;
+    }
+
+    operator VkDeviceGroupSwapchainCreateInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>( this );
+    }
+
+    operator VkDeviceGroupSwapchainCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>( this );
+    }
+
+    bool operator==( DeviceGroupSwapchainCreateInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( modes == rhs.modes );
+    }
+
+    bool operator!=( DeviceGroupSwapchainCreateInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    DeviceGroupPresentModeFlagsKHR modes;
+  };
+  static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
+
+  struct DeviceMemoryOverallocationCreateInfoAMD
+  {
+    DeviceMemoryOverallocationCreateInfoAMD( MemoryOverallocationBehaviorAMD overallocationBehavior_ = MemoryOverallocationBehaviorAMD::eDefault )
+      : overallocationBehavior( overallocationBehavior_ )
+    {}
+
+    DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) );
+    }
+
+    DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) );
+      return *this;
+    }
+
+    DeviceMemoryOverallocationCreateInfoAMD & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceMemoryOverallocationCreateInfoAMD & setOverallocationBehavior( MemoryOverallocationBehaviorAMD overallocationBehavior_ )
+    {
+      overallocationBehavior = overallocationBehavior_;
+      return *this;
+    }
+
+    operator VkDeviceMemoryOverallocationCreateInfoAMD const&() const
+    {
+      return *reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>( this );
+    }
+
+    operator VkDeviceMemoryOverallocationCreateInfoAMD &()
+    {
+      return *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>( this );
+    }
+
+    bool operator==( DeviceMemoryOverallocationCreateInfoAMD const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( overallocationBehavior == rhs.overallocationBehavior );
+    }
+
+    bool operator!=( DeviceMemoryOverallocationCreateInfoAMD const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD;
+
+  public:
+    const void* pNext = nullptr;
+    MemoryOverallocationBehaviorAMD overallocationBehavior;
+  };
+  static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "struct and wrapper have different size!" );
+
+  struct DeviceQueueGlobalPriorityCreateInfoEXT
+  {
+    DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow )
+      : globalPriority( globalPriority_ )
+    {}
+
+    DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
+    }
+
+    DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
+      return *this;
+    }
+
+    DeviceQueueGlobalPriorityCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceQueueGlobalPriorityCreateInfoEXT & setGlobalPriority( QueueGlobalPriorityEXT globalPriority_ )
+    {
+      globalPriority = globalPriority_;
+      return *this;
+    }
+
+    operator VkDeviceQueueGlobalPriorityCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>( this );
+    }
+
+    operator VkDeviceQueueGlobalPriorityCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>( this );
+    }
+
+    bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( globalPriority == rhs.globalPriority );
+    }
+
+    bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    QueueGlobalPriorityEXT globalPriority;
+  };
+  static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DeviceQueueInfo2
+  {
+    DeviceQueueInfo2( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(),
+                      uint32_t queueFamilyIndex_ = 0,
+                      uint32_t queueIndex_ = 0 )
+      : flags( flags_ )
+      , queueFamilyIndex( queueFamilyIndex_ )
+      , queueIndex( queueIndex_ )
+    {}
+
+    DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) );
+    }
+
+    DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) );
+      return *this;
+    }
+
+    DeviceQueueInfo2 & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DeviceQueueInfo2 & setFlags( DeviceQueueCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    DeviceQueueInfo2 & setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
+    {
+      queueFamilyIndex = queueFamilyIndex_;
+      return *this;
+    }
+
+    DeviceQueueInfo2 & setQueueIndex( uint32_t queueIndex_ )
+    {
+      queueIndex = queueIndex_;
+      return *this;
+    }
+
+    operator VkDeviceQueueInfo2 const&() const
+    {
+      return *reinterpret_cast<const VkDeviceQueueInfo2*>( this );
+    }
+
+    operator VkDeviceQueueInfo2 &()
+    {
+      return *reinterpret_cast<VkDeviceQueueInfo2*>( this );
+    }
+
+    bool operator==( DeviceQueueInfo2 const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( queueFamilyIndex == rhs.queueFamilyIndex )
+          && ( queueIndex == rhs.queueIndex );
+    }
+
+    bool operator!=( DeviceQueueInfo2 const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDeviceQueueInfo2;
+
+  public:
+    const void* pNext = nullptr;
+    DeviceQueueCreateFlags flags;
+    uint32_t queueFamilyIndex;
+    uint32_t queueIndex;
+  };
+  static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" );
+
+  struct DispatchIndirectCommand
+  {
+    DispatchIndirectCommand( uint32_t x_ = 0,
+                             uint32_t y_ = 0,
+                             uint32_t z_ = 0 )
+      : x( x_ )
+      , y( y_ )
+      , z( z_ )
+    {}
+
+    DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
+    }
+
+    DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
+      return *this;
+    }
+
+    DispatchIndirectCommand & setX( uint32_t x_ )
+    {
+      x = x_;
+      return *this;
+    }
+
+    DispatchIndirectCommand & setY( uint32_t y_ )
+    {
+      y = y_;
+      return *this;
+    }
+
+    DispatchIndirectCommand & setZ( uint32_t z_ )
+    {
+      z = z_;
+      return *this;
+    }
+
+    operator VkDispatchIndirectCommand const&() const
+    {
+      return *reinterpret_cast<const VkDispatchIndirectCommand*>( this );
+    }
+
+    operator VkDispatchIndirectCommand &()
+    {
+      return *reinterpret_cast<VkDispatchIndirectCommand*>( this );
+    }
+
+    bool operator==( DispatchIndirectCommand const& rhs ) const
+    {
+      return ( x == rhs.x )
+          && ( y == rhs.y )
+          && ( z == rhs.z );
+    }
+
+    bool operator!=( DispatchIndirectCommand const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t x;
+    uint32_t y;
+    uint32_t z;
+  };
+  static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" );
+
+  struct DisplayEventInfoEXT
+  {
+    DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut )
+      : displayEvent( displayEvent_ )
+    {}
+
+    DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
+    }
+
+    DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
+      return *this;
+    }
+
+    DisplayEventInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DisplayEventInfoEXT & setDisplayEvent( DisplayEventTypeEXT displayEvent_ )
+    {
+      displayEvent = displayEvent_;
+      return *this;
+    }
+
+    operator VkDisplayEventInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDisplayEventInfoEXT*>( this );
+    }
+
+    operator VkDisplayEventInfoEXT &()
+    {
+      return *reinterpret_cast<VkDisplayEventInfoEXT*>( this );
+    }
+
+    bool operator==( DisplayEventInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( displayEvent == rhs.displayEvent );
+    }
+
+    bool operator!=( DisplayEventInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDisplayEventInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    DisplayEventTypeEXT displayEvent;
+  };
+  static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DisplayModeParametersKHR
+  {
+    DisplayModeParametersKHR( Extent2D visibleRegion_ = Extent2D(),
+                              uint32_t refreshRate_ = 0 )
+      : visibleRegion( visibleRegion_ )
+      , refreshRate( refreshRate_ )
+    {}
+
+    DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
+    }
+
+    DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
+      return *this;
+    }
+
+    DisplayModeParametersKHR & setVisibleRegion( Extent2D visibleRegion_ )
+    {
+      visibleRegion = visibleRegion_;
+      return *this;
+    }
+
+    DisplayModeParametersKHR & setRefreshRate( uint32_t refreshRate_ )
+    {
+      refreshRate = refreshRate_;
+      return *this;
+    }
+
+    operator VkDisplayModeParametersKHR const&() const
+    {
+      return *reinterpret_cast<const VkDisplayModeParametersKHR*>( this );
+    }
+
+    operator VkDisplayModeParametersKHR &()
+    {
+      return *reinterpret_cast<VkDisplayModeParametersKHR*>( this );
+    }
+
+    bool operator==( DisplayModeParametersKHR const& rhs ) const
+    {
+      return ( visibleRegion == rhs.visibleRegion )
+          && ( refreshRate == rhs.refreshRate );
+    }
+
+    bool operator!=( DisplayModeParametersKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    Extent2D visibleRegion;
+    uint32_t refreshRate;
+  };
+  static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" );
+
+  struct DisplayModeCreateInfoKHR
+  {
+    DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = DisplayModeCreateFlagsKHR(),
+                              DisplayModeParametersKHR parameters_ = DisplayModeParametersKHR() )
+      : flags( flags_ )
+      , parameters( parameters_ )
+    {}
+
+    DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) );
+    }
+
+    DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) );
+      return *this;
+    }
+
+    DisplayModeCreateInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DisplayModeCreateInfoKHR & setFlags( DisplayModeCreateFlagsKHR flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    DisplayModeCreateInfoKHR & setParameters( DisplayModeParametersKHR parameters_ )
+    {
+      parameters = parameters_;
+      return *this;
+    }
+
+    operator VkDisplayModeCreateInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( this );
+    }
+
+    operator VkDisplayModeCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkDisplayModeCreateInfoKHR*>( this );
+    }
+
+    bool operator==( DisplayModeCreateInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( parameters == rhs.parameters );
+    }
+
+    bool operator!=( DisplayModeCreateInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDisplayModeCreateInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    DisplayModeCreateFlagsKHR flags;
+    DisplayModeParametersKHR parameters;
+  };
+  static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" );
+
+  struct DisplayModePropertiesKHR
+  {
+    operator VkDisplayModePropertiesKHR const&() const
+    {
+      return *reinterpret_cast<const VkDisplayModePropertiesKHR*>( this );
+    }
+
+    operator VkDisplayModePropertiesKHR &()
+    {
+      return *reinterpret_cast<VkDisplayModePropertiesKHR*>( this );
+    }
+
+    bool operator==( DisplayModePropertiesKHR const& rhs ) const
+    {
+      return ( displayMode == rhs.displayMode )
+          && ( parameters == rhs.parameters );
+    }
+
+    bool operator!=( DisplayModePropertiesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    DisplayModeKHR displayMode;
+    DisplayModeParametersKHR parameters;
+  };
+  static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" );
+
+  struct DisplayModeProperties2KHR
+  {
+    operator VkDisplayModeProperties2KHR const&() const
+    {
+      return *reinterpret_cast<const VkDisplayModeProperties2KHR*>( this );
+    }
+
+    operator VkDisplayModeProperties2KHR &()
+    {
+      return *reinterpret_cast<VkDisplayModeProperties2KHR*>( this );
+    }
+
+    bool operator==( DisplayModeProperties2KHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( displayModeProperties == rhs.displayModeProperties );
+    }
+
+    bool operator!=( DisplayModeProperties2KHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDisplayModeProperties2KHR;
+
+  public:
+    void* pNext = nullptr;
+    DisplayModePropertiesKHR displayModeProperties;
+  };
+  static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" );
+
+  struct DisplayPlaneCapabilitiesKHR
+  {
+    operator VkDisplayPlaneCapabilitiesKHR const&() const
+    {
+      return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>( this );
+    }
+
+    operator VkDisplayPlaneCapabilitiesKHR &()
+    {
+      return *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( this );
+    }
+
+    bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const
+    {
+      return ( supportedAlpha == rhs.supportedAlpha )
+          && ( minSrcPosition == rhs.minSrcPosition )
+          && ( maxSrcPosition == rhs.maxSrcPosition )
+          && ( minSrcExtent == rhs.minSrcExtent )
+          && ( maxSrcExtent == rhs.maxSrcExtent )
+          && ( minDstPosition == rhs.minDstPosition )
+          && ( maxDstPosition == rhs.maxDstPosition )
+          && ( minDstExtent == rhs.minDstExtent )
+          && ( maxDstExtent == rhs.maxDstExtent );
+    }
+
+    bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    DisplayPlaneAlphaFlagsKHR supportedAlpha;
+    Offset2D minSrcPosition;
+    Offset2D maxSrcPosition;
+    Extent2D minSrcExtent;
+    Extent2D maxSrcExtent;
+    Offset2D minDstPosition;
+    Offset2D maxDstPosition;
+    Extent2D minDstExtent;
+    Extent2D maxDstExtent;
+  };
+  static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" );
+
+  struct DisplayPlaneCapabilities2KHR
+  {
+    operator VkDisplayPlaneCapabilities2KHR const&() const
+    {
+      return *reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>( this );
+    }
+
+    operator VkDisplayPlaneCapabilities2KHR &()
+    {
+      return *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( this );
+    }
+
+    bool operator==( DisplayPlaneCapabilities2KHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( capabilities == rhs.capabilities );
+    }
+
+    bool operator!=( DisplayPlaneCapabilities2KHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR;
+
+  public:
+    void* pNext = nullptr;
+    DisplayPlaneCapabilitiesKHR capabilities;
+  };
+  static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" );
+
+  struct DisplayPlaneInfo2KHR
+  {
+    DisplayPlaneInfo2KHR( DisplayModeKHR mode_ = DisplayModeKHR(),
+                          uint32_t planeIndex_ = 0 )
+      : mode( mode_ )
+      , planeIndex( planeIndex_ )
+    {}
+
+    DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplayPlaneInfo2KHR ) );
+    }
+
+    DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplayPlaneInfo2KHR ) );
+      return *this;
+    }
+
+    DisplayPlaneInfo2KHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DisplayPlaneInfo2KHR & setMode( DisplayModeKHR mode_ )
+    {
+      mode = mode_;
+      return *this;
+    }
+
+    DisplayPlaneInfo2KHR & setPlaneIndex( uint32_t planeIndex_ )
+    {
+      planeIndex = planeIndex_;
+      return *this;
+    }
+
+    operator VkDisplayPlaneInfo2KHR const&() const
+    {
+      return *reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( this );
+    }
+
+    operator VkDisplayPlaneInfo2KHR &()
+    {
+      return *reinterpret_cast<VkDisplayPlaneInfo2KHR*>( this );
+    }
+
+    bool operator==( DisplayPlaneInfo2KHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( mode == rhs.mode )
+          && ( planeIndex == rhs.planeIndex );
+    }
+
+    bool operator!=( DisplayPlaneInfo2KHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDisplayPlaneInfo2KHR;
+
+  public:
+    const void* pNext = nullptr;
+    DisplayModeKHR mode;
+    uint32_t planeIndex;
+  };
+  static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" );
+
+  struct DisplayPlanePropertiesKHR
+  {
+    operator VkDisplayPlanePropertiesKHR const&() const
+    {
+      return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>( this );
+    }
+
+    operator VkDisplayPlanePropertiesKHR &()
+    {
+      return *reinterpret_cast<VkDisplayPlanePropertiesKHR*>( this );
+    }
+
+    bool operator==( DisplayPlanePropertiesKHR const& rhs ) const
+    {
+      return ( currentDisplay == rhs.currentDisplay )
+          && ( currentStackIndex == rhs.currentStackIndex );
+    }
+
+    bool operator!=( DisplayPlanePropertiesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    DisplayKHR currentDisplay;
+    uint32_t currentStackIndex;
+  };
+  static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" );
+
+  struct DisplayPlaneProperties2KHR
+  {
+    operator VkDisplayPlaneProperties2KHR const&() const
+    {
+      return *reinterpret_cast<const VkDisplayPlaneProperties2KHR*>( this );
+    }
+
+    operator VkDisplayPlaneProperties2KHR &()
+    {
+      return *reinterpret_cast<VkDisplayPlaneProperties2KHR*>( this );
+    }
+
+    bool operator==( DisplayPlaneProperties2KHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( displayPlaneProperties == rhs.displayPlaneProperties );
+    }
+
+    bool operator!=( DisplayPlaneProperties2KHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDisplayPlaneProperties2KHR;
+
+  public:
+    void* pNext = nullptr;
+    DisplayPlanePropertiesKHR displayPlaneProperties;
+  };
+  static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "struct and wrapper have different size!" );
+
+  struct DisplayPowerInfoEXT
+  {
+    DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff )
+      : powerState( powerState_ )
+    {}
+
+    DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
+    }
+
+    DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
+      return *this;
+    }
+
+    DisplayPowerInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DisplayPowerInfoEXT & setPowerState( DisplayPowerStateEXT powerState_ )
+    {
+      powerState = powerState_;
+      return *this;
+    }
+
+    operator VkDisplayPowerInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkDisplayPowerInfoEXT*>( this );
+    }
+
+    operator VkDisplayPowerInfoEXT &()
+    {
+      return *reinterpret_cast<VkDisplayPowerInfoEXT*>( this );
+    }
+
+    bool operator==( DisplayPowerInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( powerState == rhs.powerState );
+    }
+
+    bool operator!=( DisplayPowerInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDisplayPowerInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    DisplayPowerStateEXT powerState;
+  };
+  static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" );
+
+  struct DisplayPresentInfoKHR
+  {
+    DisplayPresentInfoKHR( Rect2D srcRect_ = Rect2D(),
+                           Rect2D dstRect_ = Rect2D(),
+                           Bool32 persistent_ = 0 )
+      : srcRect( srcRect_ )
+      , dstRect( dstRect_ )
+      , persistent( persistent_ )
+    {}
+
+    DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) );
+    }
+
+    DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) );
+      return *this;
+    }
+
+    DisplayPresentInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DisplayPresentInfoKHR & setSrcRect( Rect2D srcRect_ )
+    {
+      srcRect = srcRect_;
+      return *this;
+    }
+
+    DisplayPresentInfoKHR & setDstRect( Rect2D dstRect_ )
+    {
+      dstRect = dstRect_;
+      return *this;
+    }
+
+    DisplayPresentInfoKHR & setPersistent( Bool32 persistent_ )
+    {
+      persistent = persistent_;
+      return *this;
+    }
+
+    operator VkDisplayPresentInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkDisplayPresentInfoKHR*>( this );
+    }
+
+    operator VkDisplayPresentInfoKHR &()
+    {
+      return *reinterpret_cast<VkDisplayPresentInfoKHR*>( this );
+    }
+
+    bool operator==( DisplayPresentInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( srcRect == rhs.srcRect )
+          && ( dstRect == rhs.dstRect )
+          && ( persistent == rhs.persistent );
+    }
+
+    bool operator!=( DisplayPresentInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDisplayPresentInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    Rect2D srcRect;
+    Rect2D dstRect;
+    Bool32 persistent;
+  };
+  static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" );
+
+  struct DisplayPropertiesKHR
+  {
+    operator VkDisplayPropertiesKHR const&() const
+    {
+      return *reinterpret_cast<const VkDisplayPropertiesKHR*>( this );
+    }
+
+    operator VkDisplayPropertiesKHR &()
+    {
+      return *reinterpret_cast<VkDisplayPropertiesKHR*>( this );
+    }
+
+    bool operator==( DisplayPropertiesKHR const& rhs ) const
+    {
+      return ( display == rhs.display )
+          && ( displayName == rhs.displayName )
+          && ( physicalDimensions == rhs.physicalDimensions )
+          && ( physicalResolution == rhs.physicalResolution )
+          && ( supportedTransforms == rhs.supportedTransforms )
+          && ( planeReorderPossible == rhs.planeReorderPossible )
+          && ( persistentContent == rhs.persistentContent );
+    }
+
+    bool operator!=( DisplayPropertiesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    DisplayKHR display;
+    const char* displayName;
+    Extent2D physicalDimensions;
+    Extent2D physicalResolution;
+    SurfaceTransformFlagsKHR supportedTransforms;
+    Bool32 planeReorderPossible;
+    Bool32 persistentContent;
+  };
+  static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" );
+
+  struct DisplayProperties2KHR
+  {
+    operator VkDisplayProperties2KHR const&() const
+    {
+      return *reinterpret_cast<const VkDisplayProperties2KHR*>( this );
+    }
+
+    operator VkDisplayProperties2KHR &()
+    {
+      return *reinterpret_cast<VkDisplayProperties2KHR*>( this );
+    }
+
+    bool operator==( DisplayProperties2KHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( displayProperties == rhs.displayProperties );
+    }
+
+    bool operator!=( DisplayProperties2KHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDisplayProperties2KHR;
+
+  public:
+    void* pNext = nullptr;
+    DisplayPropertiesKHR displayProperties;
+  };
+  static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" );
+
+  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() )
+      : flags( flags_ )
+      , displayMode( displayMode_ )
+      , planeIndex( planeIndex_ )
+      , planeStackIndex( planeStackIndex_ )
+      , transform( transform_ )
+      , globalAlpha( globalAlpha_ )
+      , alphaMode( alphaMode_ )
+      , imageExtent( imageExtent_ )
+    {}
+
+    DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
+    }
+
+    DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
+      return *this;
+    }
+
+    DisplaySurfaceCreateInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DisplaySurfaceCreateInfoKHR & setFlags( DisplaySurfaceCreateFlagsKHR flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    DisplaySurfaceCreateInfoKHR & setDisplayMode( DisplayModeKHR displayMode_ )
+    {
+      displayMode = displayMode_;
+      return *this;
+    }
+
+    DisplaySurfaceCreateInfoKHR & setPlaneIndex( uint32_t planeIndex_ )
+    {
+      planeIndex = planeIndex_;
+      return *this;
+    }
+
+    DisplaySurfaceCreateInfoKHR & setPlaneStackIndex( uint32_t planeStackIndex_ )
+    {
+      planeStackIndex = planeStackIndex_;
+      return *this;
+    }
+
+    DisplaySurfaceCreateInfoKHR & setTransform( SurfaceTransformFlagBitsKHR transform_ )
+    {
+      transform = transform_;
+      return *this;
+    }
+
+    DisplaySurfaceCreateInfoKHR & setGlobalAlpha( float globalAlpha_ )
+    {
+      globalAlpha = globalAlpha_;
+      return *this;
+    }
+
+    DisplaySurfaceCreateInfoKHR & setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ )
+    {
+      alphaMode = alphaMode_;
+      return *this;
+    }
+
+    DisplaySurfaceCreateInfoKHR & setImageExtent( Extent2D imageExtent_ )
+    {
+      imageExtent = imageExtent_;
+      return *this;
+    }
+
+    operator VkDisplaySurfaceCreateInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( this );
+    }
+
+    operator VkDisplaySurfaceCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>( this );
+    }
+
+    bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( displayMode == rhs.displayMode )
+          && ( planeIndex == rhs.planeIndex )
+          && ( planeStackIndex == rhs.planeStackIndex )
+          && ( transform == rhs.transform )
+          && ( globalAlpha == rhs.globalAlpha )
+          && ( alphaMode == rhs.alphaMode )
+          && ( imageExtent == rhs.imageExtent );
+    }
+
+    bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    DisplaySurfaceCreateFlagsKHR flags;
+    DisplayModeKHR displayMode;
+    uint32_t planeIndex;
+    uint32_t planeStackIndex;
+    SurfaceTransformFlagBitsKHR transform;
+    float globalAlpha;
+    DisplayPlaneAlphaFlagBitsKHR alphaMode;
+    Extent2D imageExtent;
+  };
+  static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+
+  struct DrawIndexedIndirectCommand
+  {
+    DrawIndexedIndirectCommand( uint32_t indexCount_ = 0,
+                                uint32_t instanceCount_ = 0,
+                                uint32_t firstIndex_ = 0,
+                                int32_t vertexOffset_ = 0,
+                                uint32_t firstInstance_ = 0 )
+      : indexCount( indexCount_ )
+      , instanceCount( instanceCount_ )
+      , firstIndex( firstIndex_ )
+      , vertexOffset( vertexOffset_ )
+      , firstInstance( firstInstance_ )
+    {}
+
+    DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
+    }
+
+    DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
+      return *this;
+    }
+
+    DrawIndexedIndirectCommand & setIndexCount( uint32_t indexCount_ )
+    {
+      indexCount = indexCount_;
+      return *this;
+    }
+
+    DrawIndexedIndirectCommand & setInstanceCount( uint32_t instanceCount_ )
+    {
+      instanceCount = instanceCount_;
+      return *this;
+    }
+
+    DrawIndexedIndirectCommand & setFirstIndex( uint32_t firstIndex_ )
+    {
+      firstIndex = firstIndex_;
+      return *this;
+    }
+
+    DrawIndexedIndirectCommand & setVertexOffset( int32_t vertexOffset_ )
+    {
+      vertexOffset = vertexOffset_;
+      return *this;
+    }
+
+    DrawIndexedIndirectCommand & setFirstInstance( uint32_t firstInstance_ )
+    {
+      firstInstance = firstInstance_;
+      return *this;
+    }
+
+    operator VkDrawIndexedIndirectCommand const&() const
+    {
+      return *reinterpret_cast<const VkDrawIndexedIndirectCommand*>( this );
+    }
+
+    operator VkDrawIndexedIndirectCommand &()
+    {
+      return *reinterpret_cast<VkDrawIndexedIndirectCommand*>( this );
+    }
+
+    bool operator==( DrawIndexedIndirectCommand const& rhs ) const
+    {
+      return ( indexCount == rhs.indexCount )
+          && ( instanceCount == rhs.instanceCount )
+          && ( firstIndex == rhs.firstIndex )
+          && ( vertexOffset == rhs.vertexOffset )
+          && ( firstInstance == rhs.firstInstance );
+    }
+
+    bool operator!=( DrawIndexedIndirectCommand const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t indexCount;
+    uint32_t instanceCount;
+    uint32_t firstIndex;
+    int32_t vertexOffset;
+    uint32_t firstInstance;
+  };
+  static_assert( sizeof( DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), "struct and wrapper have different size!" );
+
+  struct DrawIndirectCommand
+  {
+    DrawIndirectCommand( uint32_t vertexCount_ = 0,
+                         uint32_t instanceCount_ = 0,
+                         uint32_t firstVertex_ = 0,
+                         uint32_t firstInstance_ = 0 )
+      : vertexCount( vertexCount_ )
+      , instanceCount( instanceCount_ )
+      , firstVertex( firstVertex_ )
+      , firstInstance( firstInstance_ )
+    {}
+
+    DrawIndirectCommand( VkDrawIndirectCommand const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
+    }
+
+    DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
+      return *this;
+    }
+
+    DrawIndirectCommand & setVertexCount( uint32_t vertexCount_ )
+    {
+      vertexCount = vertexCount_;
+      return *this;
+    }
+
+    DrawIndirectCommand & setInstanceCount( uint32_t instanceCount_ )
+    {
+      instanceCount = instanceCount_;
+      return *this;
+    }
+
+    DrawIndirectCommand & setFirstVertex( uint32_t firstVertex_ )
+    {
+      firstVertex = firstVertex_;
+      return *this;
+    }
+
+    DrawIndirectCommand & setFirstInstance( uint32_t firstInstance_ )
+    {
+      firstInstance = firstInstance_;
+      return *this;
+    }
+
+    operator VkDrawIndirectCommand const&() const
+    {
+      return *reinterpret_cast<const VkDrawIndirectCommand*>( this );
+    }
+
+    operator VkDrawIndirectCommand &()
+    {
+      return *reinterpret_cast<VkDrawIndirectCommand*>( this );
+    }
+
+    bool operator==( DrawIndirectCommand const& rhs ) const
+    {
+      return ( vertexCount == rhs.vertexCount )
+          && ( instanceCount == rhs.instanceCount )
+          && ( firstVertex == rhs.firstVertex )
+          && ( firstInstance == rhs.firstInstance );
+    }
+
+    bool operator!=( DrawIndirectCommand const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t vertexCount;
+    uint32_t instanceCount;
+    uint32_t firstVertex;
+    uint32_t firstInstance;
+  };
+  static_assert( sizeof( DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" );
+
+  struct DrawMeshTasksIndirectCommandNV
+  {
+    DrawMeshTasksIndirectCommandNV( uint32_t taskCount_ = 0,
+                                    uint32_t firstTask_ = 0 )
+      : taskCount( taskCount_ )
+      , firstTask( firstTask_ )
+    {}
+
+    DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
+    }
+
+    DrawMeshTasksIndirectCommandNV& operator=( VkDrawMeshTasksIndirectCommandNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
+      return *this;
+    }
+
+    DrawMeshTasksIndirectCommandNV & setTaskCount( uint32_t taskCount_ )
+    {
+      taskCount = taskCount_;
+      return *this;
+    }
+
+    DrawMeshTasksIndirectCommandNV & setFirstTask( uint32_t firstTask_ )
+    {
+      firstTask = firstTask_;
+      return *this;
+    }
+
+    operator VkDrawMeshTasksIndirectCommandNV const&() const
+    {
+      return *reinterpret_cast<const VkDrawMeshTasksIndirectCommandNV*>( this );
+    }
+
+    operator VkDrawMeshTasksIndirectCommandNV &()
+    {
+      return *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>( this );
+    }
+
+    bool operator==( DrawMeshTasksIndirectCommandNV const& rhs ) const
+    {
+      return ( taskCount == rhs.taskCount )
+          && ( firstTask == rhs.firstTask );
+    }
+
+    bool operator!=( DrawMeshTasksIndirectCommandNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t taskCount;
+    uint32_t firstTask;
+  };
+  static_assert( sizeof( DrawMeshTasksIndirectCommandNV ) == sizeof( VkDrawMeshTasksIndirectCommandNV ), "struct and wrapper have different size!" );
+
+  struct DrmFormatModifierPropertiesEXT
+  {
+    operator VkDrmFormatModifierPropertiesEXT const&() const
+    {
+      return *reinterpret_cast<const VkDrmFormatModifierPropertiesEXT*>( this );
+    }
+
+    operator VkDrmFormatModifierPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkDrmFormatModifierPropertiesEXT*>( this );
+    }
+
+    bool operator==( DrmFormatModifierPropertiesEXT const& rhs ) const
+    {
+      return ( drmFormatModifier == rhs.drmFormatModifier )
+          && ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount )
+          && ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures );
+    }
+
+    bool operator!=( DrmFormatModifierPropertiesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint64_t drmFormatModifier;
+    uint32_t drmFormatModifierPlaneCount;
+    FormatFeatureFlags drmFormatModifierTilingFeatures;
+  };
+  static_assert( sizeof( DrmFormatModifierPropertiesEXT ) == sizeof( VkDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
+
+  struct DrmFormatModifierPropertiesListEXT
+  {
+    DrmFormatModifierPropertiesListEXT( uint32_t drmFormatModifierCount_ = 0,
+                                        DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties_ = nullptr )
+      : drmFormatModifierCount( drmFormatModifierCount_ )
+      , pDrmFormatModifierProperties( pDrmFormatModifierProperties_ )
+    {}
+
+    DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DrmFormatModifierPropertiesListEXT ) );
+    }
+
+    DrmFormatModifierPropertiesListEXT& operator=( VkDrmFormatModifierPropertiesListEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( DrmFormatModifierPropertiesListEXT ) );
+      return *this;
+    }
+
+    DrmFormatModifierPropertiesListEXT & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DrmFormatModifierPropertiesListEXT & setDrmFormatModifierCount( uint32_t drmFormatModifierCount_ )
+    {
+      drmFormatModifierCount = drmFormatModifierCount_;
+      return *this;
+    }
+
+    DrmFormatModifierPropertiesListEXT & setPDrmFormatModifierProperties( DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties_ )
+    {
+      pDrmFormatModifierProperties = pDrmFormatModifierProperties_;
+      return *this;
+    }
+
+    operator VkDrmFormatModifierPropertiesListEXT const&() const
+    {
+      return *reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>( this );
+    }
+
+    operator VkDrmFormatModifierPropertiesListEXT &()
+    {
+      return *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>( this );
+    }
+
+    bool operator==( DrmFormatModifierPropertiesListEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( drmFormatModifierCount == rhs.drmFormatModifierCount )
+          && ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties );
+    }
+
+    bool operator!=( DrmFormatModifierPropertiesListEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t drmFormatModifierCount;
+    DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties;
+  };
+  static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "struct and wrapper have different size!" );
+
+  struct EventCreateInfo
+  {
+    EventCreateInfo( EventCreateFlags flags_ = EventCreateFlags() )
+      : flags( flags_ )
+    {}
+
+    EventCreateInfo( VkEventCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( EventCreateInfo ) );
+    }
+
+    EventCreateInfo& operator=( VkEventCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( EventCreateInfo ) );
+      return *this;
+    }
+
+    EventCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    EventCreateInfo & setFlags( EventCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    operator VkEventCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkEventCreateInfo*>( this );
+    }
+
+    operator VkEventCreateInfo &()
+    {
+      return *reinterpret_cast<VkEventCreateInfo*>( this );
+    }
+
+    bool operator==( EventCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags );
+    }
+
+    bool operator!=( EventCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eEventCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    EventCreateFlags flags;
+  };
+  static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" );
+
+  struct ExportFenceCreateInfo
+  {
+    ExportFenceCreateInfo( ExternalFenceHandleTypeFlags handleTypes_ = ExternalFenceHandleTypeFlags() )
+      : handleTypes( handleTypes_ )
+    {}
+
+    ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) );
+    }
+
+    ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) );
+      return *this;
+    }
+
+    ExportFenceCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ExportFenceCreateInfo & setHandleTypes( ExternalFenceHandleTypeFlags handleTypes_ )
+    {
+      handleTypes = handleTypes_;
+      return *this;
+    }
+
+    operator VkExportFenceCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkExportFenceCreateInfo*>( this );
+    }
+
+    operator VkExportFenceCreateInfo &()
+    {
+      return *reinterpret_cast<VkExportFenceCreateInfo*>( this );
+    }
+
+    bool operator==( ExportFenceCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( handleTypes == rhs.handleTypes );
+    }
+
+    bool operator!=( ExportFenceCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExportFenceCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    ExternalFenceHandleTypeFlags handleTypes;
+  };
+  static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct ExportFenceWin32HandleInfoKHR
+  {
+    ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+                                   DWORD dwAccess_ = 0,
+                                   LPCWSTR name_ = nullptr )
+      : pAttributes( pAttributes_ )
+      , dwAccess( dwAccess_ )
+      , name( name_ )
+    {}
+
+    ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) );
+    }
+
+    ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) );
+      return *this;
+    }
+
+    ExportFenceWin32HandleInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ExportFenceWin32HandleInfoKHR & setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
+    {
+      pAttributes = pAttributes_;
+      return *this;
+    }
+
+    ExportFenceWin32HandleInfoKHR & setDwAccess( DWORD dwAccess_ )
+    {
+      dwAccess = dwAccess_;
+      return *this;
+    }
+
+    ExportFenceWin32HandleInfoKHR & setName( LPCWSTR name_ )
+    {
+      name = name_;
+      return *this;
+    }
+
+    operator VkExportFenceWin32HandleInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>( this );
+    }
+
+    operator VkExportFenceWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>( this );
+    }
+
+    bool operator==( ExportFenceWin32HandleInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( pAttributes == rhs.pAttributes )
+          && ( dwAccess == rhs.dwAccess )
+          && ( name == rhs.name );
+    }
+
+    bool operator!=( ExportFenceWin32HandleInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    const SECURITY_ATTRIBUTES* pAttributes;
+    DWORD dwAccess;
+    LPCWSTR name;
+  };
+  static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  struct ExportMemoryAllocateInfo
+  {
+    ExportMemoryAllocateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
+      : handleTypes( handleTypes_ )
+    {}
+
+    ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) );
+    }
+
+    ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) );
+      return *this;
+    }
+
+    ExportMemoryAllocateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ExportMemoryAllocateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
+    {
+      handleTypes = handleTypes_;
+      return *this;
+    }
+
+    operator VkExportMemoryAllocateInfo const&() const
+    {
+      return *reinterpret_cast<const VkExportMemoryAllocateInfo*>( this );
+    }
+
+    operator VkExportMemoryAllocateInfo &()
+    {
+      return *reinterpret_cast<VkExportMemoryAllocateInfo*>( this );
+    }
+
+    bool operator==( ExportMemoryAllocateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( handleTypes == rhs.handleTypes );
+    }
+
+    bool operator!=( ExportMemoryAllocateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExportMemoryAllocateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    ExternalMemoryHandleTypeFlags handleTypes;
+  };
+  static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "struct and wrapper have different size!" );
+
+  struct ExportMemoryAllocateInfoNV
+  {
+    ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
+      : handleTypes( handleTypes_ )
+    {}
+
+    ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
+    }
+
+    ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
+      return *this;
+    }
+
+    ExportMemoryAllocateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ExportMemoryAllocateInfoNV & setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
+    {
+      handleTypes = handleTypes_;
+      return *this;
+    }
+
+    operator VkExportMemoryAllocateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>( this );
+    }
+
+    operator VkExportMemoryAllocateInfoNV &()
+    {
+      return *reinterpret_cast<VkExportMemoryAllocateInfoNV*>( this );
+    }
+
+    bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( handleTypes == rhs.handleTypes );
+    }
+
+    bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExportMemoryAllocateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    ExternalMemoryHandleTypeFlagsNV handleTypes;
+  };
+  static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct ExportMemoryWin32HandleInfoKHR
+  {
+    ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+                                    DWORD dwAccess_ = 0,
+                                    LPCWSTR name_ = nullptr )
+      : pAttributes( pAttributes_ )
+      , dwAccess( dwAccess_ )
+      , name( name_ )
+    {}
+
+    ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) );
+    }
+
+    ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) );
+      return *this;
+    }
+
+    ExportMemoryWin32HandleInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ExportMemoryWin32HandleInfoKHR & setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
+    {
+      pAttributes = pAttributes_;
+      return *this;
+    }
+
+    ExportMemoryWin32HandleInfoKHR & setDwAccess( DWORD dwAccess_ )
+    {
+      dwAccess = dwAccess_;
+      return *this;
+    }
+
+    ExportMemoryWin32HandleInfoKHR & setName( LPCWSTR name_ )
+    {
+      name = name_;
+      return *this;
+    }
+
+    operator VkExportMemoryWin32HandleInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>( this );
+    }
+
+    operator VkExportMemoryWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>( this );
+    }
+
+    bool operator==( ExportMemoryWin32HandleInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( pAttributes == rhs.pAttributes )
+          && ( dwAccess == rhs.dwAccess )
+          && ( name == rhs.name );
+    }
+
+    bool operator!=( ExportMemoryWin32HandleInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    const SECURITY_ATTRIBUTES* pAttributes;
+    DWORD dwAccess;
+    LPCWSTR name;
+  };
+  static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct ExportMemoryWin32HandleInfoNV
+  {
+    ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+                                   DWORD dwAccess_ = 0 )
+      : pAttributes( pAttributes_ )
+      , dwAccess( dwAccess_ )
+    {}
+
+    ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) );
+    }
+
+    ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) );
+      return *this;
+    }
+
+    ExportMemoryWin32HandleInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ExportMemoryWin32HandleInfoNV & setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
+    {
+      pAttributes = pAttributes_;
+      return *this;
+    }
+
+    ExportMemoryWin32HandleInfoNV & setDwAccess( DWORD dwAccess_ )
+    {
+      dwAccess = dwAccess_;
+      return *this;
+    }
+
+    operator VkExportMemoryWin32HandleInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>( this );
+    }
+
+    operator VkExportMemoryWin32HandleInfoNV &()
+    {
+      return *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>( this );
+    }
+
+    bool operator==( ExportMemoryWin32HandleInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( pAttributes == rhs.pAttributes )
+          && ( dwAccess == rhs.dwAccess );
+    }
+
+    bool operator!=( ExportMemoryWin32HandleInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    const SECURITY_ATTRIBUTES* pAttributes;
+    DWORD dwAccess;
+  };
+  static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  struct ExportSemaphoreCreateInfo
+  {
+    ExportSemaphoreCreateInfo( ExternalSemaphoreHandleTypeFlags handleTypes_ = ExternalSemaphoreHandleTypeFlags() )
+      : handleTypes( handleTypes_ )
+    {}
+
+    ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) );
+    }
+
+    ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) );
+      return *this;
+    }
+
+    ExportSemaphoreCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ExportSemaphoreCreateInfo & setHandleTypes( ExternalSemaphoreHandleTypeFlags handleTypes_ )
+    {
+      handleTypes = handleTypes_;
+      return *this;
+    }
+
+    operator VkExportSemaphoreCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkExportSemaphoreCreateInfo*>( this );
+    }
+
+    operator VkExportSemaphoreCreateInfo &()
+    {
+      return *reinterpret_cast<VkExportSemaphoreCreateInfo*>( this );
+    }
+
+    bool operator==( ExportSemaphoreCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( handleTypes == rhs.handleTypes );
+    }
+
+    bool operator!=( ExportSemaphoreCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExportSemaphoreCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    ExternalSemaphoreHandleTypeFlags handleTypes;
+  };
+  static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct ExportSemaphoreWin32HandleInfoKHR
+  {
+    ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+                                       DWORD dwAccess_ = 0,
+                                       LPCWSTR name_ = nullptr )
+      : pAttributes( pAttributes_ )
+      , dwAccess( dwAccess_ )
+      , name( name_ )
+    {}
+
+    ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) );
+    }
+
+    ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) );
+      return *this;
+    }
+
+    ExportSemaphoreWin32HandleInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ExportSemaphoreWin32HandleInfoKHR & setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
+    {
+      pAttributes = pAttributes_;
+      return *this;
+    }
+
+    ExportSemaphoreWin32HandleInfoKHR & setDwAccess( DWORD dwAccess_ )
+    {
+      dwAccess = dwAccess_;
+      return *this;
+    }
+
+    ExportSemaphoreWin32HandleInfoKHR & setName( LPCWSTR name_ )
+    {
+      name = name_;
+      return *this;
+    }
+
+    operator VkExportSemaphoreWin32HandleInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>( this );
+    }
+
+    operator VkExportSemaphoreWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>( this );
+    }
+
+    bool operator==( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( pAttributes == rhs.pAttributes )
+          && ( dwAccess == rhs.dwAccess )
+          && ( name == rhs.name );
+    }
+
+    bool operator!=( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    const SECURITY_ATTRIBUTES* pAttributes;
+    DWORD dwAccess;
+    LPCWSTR name;
+  };
+  static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  struct ExtensionProperties
+  {
+    operator VkExtensionProperties const&() const
+    {
+      return *reinterpret_cast<const VkExtensionProperties*>( this );
+    }
+
+    operator VkExtensionProperties &()
+    {
+      return *reinterpret_cast<VkExtensionProperties*>( this );
+    }
+
+    bool operator==( ExtensionProperties const& rhs ) const
+    {
+      return ( memcmp( extensionName, rhs.extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
+          && ( specVersion == rhs.specVersion );
+    }
+
+    bool operator!=( ExtensionProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
+    uint32_t specVersion;
+  };
+  static_assert( sizeof( ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" );
+
+  struct ExternalMemoryProperties
+  {
+    operator VkExternalMemoryProperties const&() const
+    {
+      return *reinterpret_cast<const VkExternalMemoryProperties*>( this );
+    }
+
+    operator VkExternalMemoryProperties &()
+    {
+      return *reinterpret_cast<VkExternalMemoryProperties*>( this );
+    }
+
+    bool operator==( ExternalMemoryProperties const& rhs ) const
+    {
+      return ( externalMemoryFeatures == rhs.externalMemoryFeatures )
+          && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
+          && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
+    }
+
+    bool operator!=( ExternalMemoryProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ExternalMemoryFeatureFlags externalMemoryFeatures;
+    ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;
+    ExternalMemoryHandleTypeFlags compatibleHandleTypes;
+  };
+  static_assert( sizeof( ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), "struct and wrapper have different size!" );
+
+  struct ExternalBufferProperties
+  {
+    operator VkExternalBufferProperties const&() const
+    {
+      return *reinterpret_cast<const VkExternalBufferProperties*>( this );
+    }
+
+    operator VkExternalBufferProperties &()
+    {
+      return *reinterpret_cast<VkExternalBufferProperties*>( this );
+    }
+
+    bool operator==( ExternalBufferProperties const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( externalMemoryProperties == rhs.externalMemoryProperties );
+    }
+
+    bool operator!=( ExternalBufferProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExternalBufferProperties;
+
+  public:
+    void* pNext = nullptr;
+    ExternalMemoryProperties externalMemoryProperties;
+  };
+  static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "struct and wrapper have different size!" );
+
+  struct ExternalFenceProperties
+  {
+    operator VkExternalFenceProperties const&() const
+    {
+      return *reinterpret_cast<const VkExternalFenceProperties*>( this );
+    }
+
+    operator VkExternalFenceProperties &()
+    {
+      return *reinterpret_cast<VkExternalFenceProperties*>( this );
+    }
+
+    bool operator==( ExternalFenceProperties const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
+          && ( compatibleHandleTypes == rhs.compatibleHandleTypes )
+          && ( externalFenceFeatures == rhs.externalFenceFeatures );
+    }
+
+    bool operator!=( ExternalFenceProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExternalFenceProperties;
+
+  public:
+    void* pNext = nullptr;
+    ExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
+    ExternalFenceHandleTypeFlags compatibleHandleTypes;
+    ExternalFenceFeatureFlags externalFenceFeatures;
+  };
+  static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  struct ExternalFormatANDROID
+  {
+    ExternalFormatANDROID( uint64_t externalFormat_ = 0 )
+      : externalFormat( externalFormat_ )
+    {}
+
+    ExternalFormatANDROID( VkExternalFormatANDROID const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExternalFormatANDROID ) );
+    }
+
+    ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExternalFormatANDROID ) );
+      return *this;
+    }
+
+    ExternalFormatANDROID & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ExternalFormatANDROID & setExternalFormat( uint64_t externalFormat_ )
+    {
+      externalFormat = externalFormat_;
+      return *this;
+    }
+
+    operator VkExternalFormatANDROID const&() const
+    {
+      return *reinterpret_cast<const VkExternalFormatANDROID*>( this );
+    }
+
+    operator VkExternalFormatANDROID &()
+    {
+      return *reinterpret_cast<VkExternalFormatANDROID*>( this );
+    }
+
+    bool operator==( ExternalFormatANDROID const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( externalFormat == rhs.externalFormat );
+    }
+
+    bool operator!=( ExternalFormatANDROID const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExternalFormatANDROID;
+
+  public:
+    void* pNext = nullptr;
+    uint64_t externalFormat;
+  };
+  static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+  struct ExternalImageFormatProperties
+  {
+    operator VkExternalImageFormatProperties const&() const
+    {
+      return *reinterpret_cast<const VkExternalImageFormatProperties*>( this );
+    }
+
+    operator VkExternalImageFormatProperties &()
+    {
+      return *reinterpret_cast<VkExternalImageFormatProperties*>( this );
+    }
+
+    bool operator==( ExternalImageFormatProperties const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( externalMemoryProperties == rhs.externalMemoryProperties );
+    }
+
+    bool operator!=( ExternalImageFormatProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExternalImageFormatProperties;
+
+  public:
+    void* pNext = nullptr;
+    ExternalMemoryProperties externalMemoryProperties;
+  };
+  static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "struct and wrapper have different size!" );
+
+  struct ImageFormatProperties
+  {
+    operator VkImageFormatProperties const&() const
+    {
+      return *reinterpret_cast<const VkImageFormatProperties*>( this );
+    }
+
+    operator VkImageFormatProperties &()
+    {
+      return *reinterpret_cast<VkImageFormatProperties*>( this );
+    }
+
+    bool operator==( ImageFormatProperties const& rhs ) const
+    {
+      return ( maxExtent == rhs.maxExtent )
+          && ( maxMipLevels == rhs.maxMipLevels )
+          && ( maxArrayLayers == rhs.maxArrayLayers )
+          && ( sampleCounts == rhs.sampleCounts )
+          && ( maxResourceSize == rhs.maxResourceSize );
+    }
+
+    bool operator!=( ImageFormatProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    Extent3D maxExtent;
+    uint32_t maxMipLevels;
+    uint32_t maxArrayLayers;
+    SampleCountFlags sampleCounts;
+    DeviceSize maxResourceSize;
+  };
+  static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" );
+
+  struct ExternalImageFormatPropertiesNV
+  {
+    operator VkExternalImageFormatPropertiesNV const&() const
+    {
+      return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>( this );
+    }
+
+    operator VkExternalImageFormatPropertiesNV &()
+    {
+      return *reinterpret_cast<VkExternalImageFormatPropertiesNV*>( this );
+    }
+
+    bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const
+    {
+      return ( imageFormatProperties == rhs.imageFormatProperties )
+          && ( externalMemoryFeatures == rhs.externalMemoryFeatures )
+          && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
+          && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
+    }
+
+    bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ImageFormatProperties imageFormatProperties;
+    ExternalMemoryFeatureFlagsNV externalMemoryFeatures;
+    ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
+    ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
+  };
+  static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" );
+
+  struct ExternalMemoryBufferCreateInfo
+  {
+    ExternalMemoryBufferCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
+      : handleTypes( handleTypes_ )
+    {}
+
+    ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) );
+    }
+
+    ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) );
+      return *this;
+    }
+
+    ExternalMemoryBufferCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ExternalMemoryBufferCreateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
+    {
+      handleTypes = handleTypes_;
+      return *this;
+    }
+
+    operator VkExternalMemoryBufferCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>( this );
+    }
+
+    operator VkExternalMemoryBufferCreateInfo &()
+    {
+      return *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>( this );
+    }
+
+    bool operator==( ExternalMemoryBufferCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( handleTypes == rhs.handleTypes );
+    }
+
+    bool operator!=( ExternalMemoryBufferCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExternalMemoryBufferCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    ExternalMemoryHandleTypeFlags handleTypes;
+  };
+  static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "struct and wrapper have different size!" );
+
+  struct ExternalMemoryImageCreateInfo
+  {
+    ExternalMemoryImageCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
+      : handleTypes( handleTypes_ )
+    {}
+
+    ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) );
+    }
+
+    ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) );
+      return *this;
+    }
+
+    ExternalMemoryImageCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ExternalMemoryImageCreateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
+    {
+      handleTypes = handleTypes_;
+      return *this;
+    }
+
+    operator VkExternalMemoryImageCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkExternalMemoryImageCreateInfo*>( this );
+    }
+
+    operator VkExternalMemoryImageCreateInfo &()
+    {
+      return *reinterpret_cast<VkExternalMemoryImageCreateInfo*>( this );
+    }
+
+    bool operator==( ExternalMemoryImageCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( handleTypes == rhs.handleTypes );
+    }
+
+    bool operator!=( ExternalMemoryImageCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExternalMemoryImageCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    ExternalMemoryHandleTypeFlags handleTypes;
+  };
+  static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "struct and wrapper have different size!" );
+
+  struct ExternalMemoryImageCreateInfoNV
+  {
+    ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
+      : handleTypes( handleTypes_ )
+    {}
+
+    ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
+    }
+
+    ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
+      return *this;
+    }
+
+    ExternalMemoryImageCreateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ExternalMemoryImageCreateInfoNV & setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
+    {
+      handleTypes = handleTypes_;
+      return *this;
+    }
+
+    operator VkExternalMemoryImageCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>( this );
+    }
+
+    operator VkExternalMemoryImageCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>( this );
+    }
+
+    bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( handleTypes == rhs.handleTypes );
+    }
+
+    bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    ExternalMemoryHandleTypeFlagsNV handleTypes;
+  };
+  static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
+
+  struct ExternalSemaphoreProperties
+  {
+    operator VkExternalSemaphoreProperties const&() const
+    {
+      return *reinterpret_cast<const VkExternalSemaphoreProperties*>( this );
+    }
+
+    operator VkExternalSemaphoreProperties &()
+    {
+      return *reinterpret_cast<VkExternalSemaphoreProperties*>( this );
+    }
+
+    bool operator==( ExternalSemaphoreProperties const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
+          && ( compatibleHandleTypes == rhs.compatibleHandleTypes )
+          && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures );
+    }
+
+    bool operator!=( ExternalSemaphoreProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eExternalSemaphoreProperties;
+
+  public:
+    void* pNext = nullptr;
+    ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
+    ExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
+    ExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
+  };
+  static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "struct and wrapper have different size!" );
+
+  struct FenceCreateInfo
+  {
+    FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() )
+      : flags( flags_ )
+    {}
+
+    FenceCreateInfo( VkFenceCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
+    }
+
+    FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
+      return *this;
+    }
+
+    FenceCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    FenceCreateInfo & setFlags( FenceCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    operator VkFenceCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkFenceCreateInfo*>( this );
+    }
+
+    operator VkFenceCreateInfo &()
+    {
+      return *reinterpret_cast<VkFenceCreateInfo*>( this );
+    }
+
+    bool operator==( FenceCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags );
+    }
+
+    bool operator!=( FenceCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eFenceCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    FenceCreateFlags flags;
+  };
+  static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
+
+  struct FenceGetFdInfoKHR
+  {
+    FenceGetFdInfoKHR( Fence fence_ = Fence(),
+                       ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+      : fence( fence_ )
+      , handleType( handleType_ )
+    {}
+
+    FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
+    }
+
+    FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
+      return *this;
+    }
+
+    FenceGetFdInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    FenceGetFdInfoKHR & setFence( Fence fence_ )
+    {
+      fence = fence_;
+      return *this;
+    }
+
+    FenceGetFdInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    operator VkFenceGetFdInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkFenceGetFdInfoKHR*>( this );
+    }
+
+    operator VkFenceGetFdInfoKHR &()
+    {
+      return *reinterpret_cast<VkFenceGetFdInfoKHR*>( this );
+    }
+
+    bool operator==( FenceGetFdInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( fence == rhs.fence )
+          && ( handleType == rhs.handleType );
+    }
+
+    bool operator!=( FenceGetFdInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eFenceGetFdInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    Fence fence;
+    ExternalFenceHandleTypeFlagBits handleType;
+  };
+  static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct FenceGetWin32HandleInfoKHR
+  {
+    FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(),
+                                ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+      : fence( fence_ )
+      , handleType( handleType_ )
+    {}
+
+    FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
+    }
+
+    FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
+      return *this;
+    }
+
+    FenceGetWin32HandleInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    FenceGetWin32HandleInfoKHR & setFence( Fence fence_ )
+    {
+      fence = fence_;
+      return *this;
+    }
+
+    FenceGetWin32HandleInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    operator VkFenceGetWin32HandleInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( this );
+    }
+
+    operator VkFenceGetWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>( this );
+    }
+
+    bool operator==( FenceGetWin32HandleInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( fence == rhs.fence )
+          && ( handleType == rhs.handleType );
+    }
+
+    bool operator!=( FenceGetWin32HandleInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    Fence fence;
+    ExternalFenceHandleTypeFlagBits handleType;
+  };
+  static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  struct FormatProperties
+  {
+    operator VkFormatProperties const&() const
+    {
+      return *reinterpret_cast<const VkFormatProperties*>( this );
+    }
+
+    operator VkFormatProperties &()
+    {
+      return *reinterpret_cast<VkFormatProperties*>( this );
+    }
+
+    bool operator==( FormatProperties const& rhs ) const
+    {
+      return ( linearTilingFeatures == rhs.linearTilingFeatures )
+          && ( optimalTilingFeatures == rhs.optimalTilingFeatures )
+          && ( bufferFeatures == rhs.bufferFeatures );
+    }
+
+    bool operator!=( FormatProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    FormatFeatureFlags linearTilingFeatures;
+    FormatFeatureFlags optimalTilingFeatures;
+    FormatFeatureFlags bufferFeatures;
+  };
+  static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" );
+
+  struct FormatProperties2
+  {
+    operator VkFormatProperties2 const&() const
+    {
+      return *reinterpret_cast<const VkFormatProperties2*>( this );
+    }
+
+    operator VkFormatProperties2 &()
+    {
+      return *reinterpret_cast<VkFormatProperties2*>( this );
+    }
+
+    bool operator==( FormatProperties2 const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( formatProperties == rhs.formatProperties );
+    }
+
+    bool operator!=( FormatProperties2 const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eFormatProperties2;
+
+  public:
+    void* pNext = nullptr;
+    FormatProperties formatProperties;
+  };
+  static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" );
+
+  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 )
+      : flags( flags_ )
+      , renderPass( renderPass_ )
+      , attachmentCount( attachmentCount_ )
+      , pAttachments( pAttachments_ )
+      , width( width_ )
+      , height( height_ )
+      , layers( layers_ )
+    {}
+
+    FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) );
+    }
+
+    FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) );
+      return *this;
+    }
+
+    FramebufferCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    FramebufferCreateInfo & setFlags( FramebufferCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    FramebufferCreateInfo & setRenderPass( RenderPass renderPass_ )
+    {
+      renderPass = renderPass_;
+      return *this;
+    }
+
+    FramebufferCreateInfo & setAttachmentCount( uint32_t attachmentCount_ )
+    {
+      attachmentCount = attachmentCount_;
+      return *this;
+    }
+
+    FramebufferCreateInfo & setPAttachments( const ImageView* pAttachments_ )
+    {
+      pAttachments = pAttachments_;
+      return *this;
+    }
+
+    FramebufferCreateInfo & setWidth( uint32_t width_ )
+    {
+      width = width_;
+      return *this;
+    }
+
+    FramebufferCreateInfo & setHeight( uint32_t height_ )
+    {
+      height = height_;
+      return *this;
+    }
+
+    FramebufferCreateInfo & setLayers( uint32_t layers_ )
+    {
+      layers = layers_;
+      return *this;
+    }
+
+    operator VkFramebufferCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkFramebufferCreateInfo*>( this );
+    }
+
+    operator VkFramebufferCreateInfo &()
+    {
+      return *reinterpret_cast<VkFramebufferCreateInfo*>( this );
+    }
+
+    bool operator==( FramebufferCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( renderPass == rhs.renderPass )
+          && ( attachmentCount == rhs.attachmentCount )
+          && ( pAttachments == rhs.pAttachments )
+          && ( width == rhs.width )
+          && ( height == rhs.height )
+          && ( layers == rhs.layers );
+    }
+
+    bool operator!=( FramebufferCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eFramebufferCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    FramebufferCreateFlags flags;
+    RenderPass renderPass;
+    uint32_t attachmentCount;
+    const ImageView* pAttachments;
+    uint32_t width;
+    uint32_t height;
+    uint32_t layers;
+  };
+  static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "struct and wrapper have different size!" );
+
+  struct VertexInputBindingDescription
+  {
+    VertexInputBindingDescription( uint32_t binding_ = 0,
+                                   uint32_t stride_ = 0,
+                                   VertexInputRate inputRate_ = VertexInputRate::eVertex )
+      : binding( binding_ )
+      , stride( stride_ )
+      , inputRate( inputRate_ )
+    {}
+
+    VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
+    }
+
+    VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
+      return *this;
+    }
+
+    VertexInputBindingDescription & setBinding( uint32_t binding_ )
+    {
+      binding = binding_;
+      return *this;
+    }
+
+    VertexInputBindingDescription & setStride( uint32_t stride_ )
+    {
+      stride = stride_;
+      return *this;
+    }
+
+    VertexInputBindingDescription & setInputRate( VertexInputRate inputRate_ )
+    {
+      inputRate = inputRate_;
+      return *this;
+    }
+
+    operator VkVertexInputBindingDescription const&() const
+    {
+      return *reinterpret_cast<const VkVertexInputBindingDescription*>( this );
+    }
+
+    operator VkVertexInputBindingDescription &()
+    {
+      return *reinterpret_cast<VkVertexInputBindingDescription*>( this );
+    }
+
+    bool operator==( VertexInputBindingDescription const& rhs ) const
+    {
+      return ( binding == rhs.binding )
+          && ( stride == rhs.stride )
+          && ( inputRate == rhs.inputRate );
+    }
+
+    bool operator!=( VertexInputBindingDescription const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t binding;
+    uint32_t stride;
+    VertexInputRate inputRate;
+  };
+  static_assert( sizeof( VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), "struct and wrapper have different size!" );
+
+  struct VertexInputAttributeDescription
+  {
+    VertexInputAttributeDescription( uint32_t location_ = 0,
+                                     uint32_t binding_ = 0,
+                                     Format format_ = Format::eUndefined,
+                                     uint32_t offset_ = 0 )
+      : location( location_ )
+      , binding( binding_ )
+      , format( format_ )
+      , offset( offset_ )
+    {}
+
+    VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
+    }
+
+    VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
+      return *this;
+    }
+
+    VertexInputAttributeDescription & setLocation( uint32_t location_ )
+    {
+      location = location_;
+      return *this;
+    }
+
+    VertexInputAttributeDescription & setBinding( uint32_t binding_ )
+    {
+      binding = binding_;
+      return *this;
+    }
+
+    VertexInputAttributeDescription & setFormat( Format format_ )
+    {
+      format = format_;
+      return *this;
+    }
+
+    VertexInputAttributeDescription & setOffset( uint32_t offset_ )
+    {
+      offset = offset_;
+      return *this;
+    }
+
+    operator VkVertexInputAttributeDescription const&() const
+    {
+      return *reinterpret_cast<const VkVertexInputAttributeDescription*>( this );
+    }
+
+    operator VkVertexInputAttributeDescription &()
+    {
+      return *reinterpret_cast<VkVertexInputAttributeDescription*>( this );
+    }
+
+    bool operator==( VertexInputAttributeDescription const& rhs ) const
+    {
+      return ( location == rhs.location )
+          && ( binding == rhs.binding )
+          && ( format == rhs.format )
+          && ( offset == rhs.offset );
+    }
+
+    bool operator!=( VertexInputAttributeDescription const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t location;
+    uint32_t binding;
+    Format format;
+    uint32_t offset;
+  };
+  static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" );
+
   struct PipelineVertexInputStateCreateInfo
   {
     PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_ = PipelineVertexInputStateCreateFlags(),
@@ -10381,8 +28225,7 @@ public:
       , pVertexBindingDescriptions( pVertexBindingDescriptions_ )
       , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ )
       , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ )
-    {
-    }
+    {}
 
     PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs )
     {
@@ -10394,37 +28237,38 @@ public:
       memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) );
       return *this;
     }
-    PipelineVertexInputStateCreateInfo& setPNext( const void* pNext_ )
+
+    PipelineVertexInputStateCreateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PipelineVertexInputStateCreateInfo& setFlags( PipelineVertexInputStateCreateFlags flags_ )
+    PipelineVertexInputStateCreateInfo & setFlags( PipelineVertexInputStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineVertexInputStateCreateInfo& setVertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount_ )
+    PipelineVertexInputStateCreateInfo & setVertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount_ )
     {
       vertexBindingDescriptionCount = vertexBindingDescriptionCount_;
       return *this;
     }
 
-    PipelineVertexInputStateCreateInfo& setPVertexBindingDescriptions( const VertexInputBindingDescription* pVertexBindingDescriptions_ )
+    PipelineVertexInputStateCreateInfo & setPVertexBindingDescriptions( const VertexInputBindingDescription* pVertexBindingDescriptions_ )
     {
       pVertexBindingDescriptions = pVertexBindingDescriptions_;
       return *this;
     }
 
-    PipelineVertexInputStateCreateInfo& setVertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount_ )
+    PipelineVertexInputStateCreateInfo & setVertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount_ )
     {
       vertexAttributeDescriptionCount = vertexAttributeDescriptionCount_;
       return *this;
     }
 
-    PipelineVertexInputStateCreateInfo& setPVertexAttributeDescriptions( const VertexInputAttributeDescription* pVertexAttributeDescriptions_ )
+    PipelineVertexInputStateCreateInfo & setPVertexAttributeDescriptions( const VertexInputAttributeDescription* pVertexAttributeDescriptions_ )
     {
       pVertexAttributeDescriptions = pVertexAttributeDescriptions_;
       return *this;
@@ -10432,12 +28276,12 @@ public:
 
     operator VkPipelineVertexInputStateCreateInfo const&() const
     {
-      return *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>(this);
+      return *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>( this );
     }
 
     operator VkPipelineVertexInputStateCreateInfo &()
     {
-      return *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this);
+      return *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>( this );
     }
 
     bool operator==( PipelineVertexInputStateCreateInfo const& rhs ) const
@@ -10477,8 +28321,7 @@ public:
       : flags( flags_ )
       , topology( topology_ )
       , primitiveRestartEnable( primitiveRestartEnable_ )
-    {
-    }
+    {}
 
     PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs )
     {
@@ -10490,25 +28333,26 @@ public:
       memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) );
       return *this;
     }
-    PipelineInputAssemblyStateCreateInfo& setPNext( const void* pNext_ )
+
+    PipelineInputAssemblyStateCreateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PipelineInputAssemblyStateCreateInfo& setFlags( PipelineInputAssemblyStateCreateFlags flags_ )
+    PipelineInputAssemblyStateCreateInfo & setFlags( PipelineInputAssemblyStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineInputAssemblyStateCreateInfo& setTopology( PrimitiveTopology topology_ )
+    PipelineInputAssemblyStateCreateInfo & setTopology( PrimitiveTopology topology_ )
     {
       topology = topology_;
       return *this;
     }
 
-    PipelineInputAssemblyStateCreateInfo& setPrimitiveRestartEnable( Bool32 primitiveRestartEnable_ )
+    PipelineInputAssemblyStateCreateInfo & setPrimitiveRestartEnable( Bool32 primitiveRestartEnable_ )
     {
       primitiveRestartEnable = primitiveRestartEnable_;
       return *this;
@@ -10516,12 +28360,12 @@ public:
 
     operator VkPipelineInputAssemblyStateCreateInfo const&() const
     {
-      return *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>(this);
+      return *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>( this );
     }
 
     operator VkPipelineInputAssemblyStateCreateInfo &()
     {
-      return *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>(this);
+      return *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>( this );
     }
 
     bool operator==( PipelineInputAssemblyStateCreateInfo const& rhs ) const
@@ -10555,8 +28399,7 @@ public:
                                          uint32_t patchControlPoints_ = 0 )
       : flags( flags_ )
       , patchControlPoints( patchControlPoints_ )
-    {
-    }
+    {}
 
     PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs )
     {
@@ -10568,19 +28411,20 @@ public:
       memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) );
       return *this;
     }
-    PipelineTessellationStateCreateInfo& setPNext( const void* pNext_ )
+
+    PipelineTessellationStateCreateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PipelineTessellationStateCreateInfo& setFlags( PipelineTessellationStateCreateFlags flags_ )
+    PipelineTessellationStateCreateInfo & setFlags( PipelineTessellationStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineTessellationStateCreateInfo& setPatchControlPoints( uint32_t patchControlPoints_ )
+    PipelineTessellationStateCreateInfo & setPatchControlPoints( uint32_t patchControlPoints_ )
     {
       patchControlPoints = patchControlPoints_;
       return *this;
@@ -10588,12 +28432,12 @@ public:
 
     operator VkPipelineTessellationStateCreateInfo const&() const
     {
-      return *reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>(this);
+      return *reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>( this );
     }
 
     operator VkPipelineTessellationStateCreateInfo &()
     {
-      return *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this);
+      return *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>( this );
     }
 
     bool operator==( PipelineTessellationStateCreateInfo const& rhs ) const
@@ -10619,6 +28463,103 @@ public:
   };
   static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" );
 
+  struct Viewport
+  {
+    Viewport( float x_ = 0,
+              float y_ = 0,
+              float width_ = 0,
+              float height_ = 0,
+              float minDepth_ = 0,
+              float maxDepth_ = 0 )
+      : x( x_ )
+      , y( y_ )
+      , width( width_ )
+      , height( height_ )
+      , minDepth( minDepth_ )
+      , maxDepth( maxDepth_ )
+    {}
+
+    Viewport( VkViewport const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Viewport ) );
+    }
+
+    Viewport& operator=( VkViewport const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Viewport ) );
+      return *this;
+    }
+
+    Viewport & setX( float x_ )
+    {
+      x = x_;
+      return *this;
+    }
+
+    Viewport & setY( float y_ )
+    {
+      y = y_;
+      return *this;
+    }
+
+    Viewport & setWidth( float width_ )
+    {
+      width = width_;
+      return *this;
+    }
+
+    Viewport & setHeight( float height_ )
+    {
+      height = height_;
+      return *this;
+    }
+
+    Viewport & setMinDepth( float minDepth_ )
+    {
+      minDepth = minDepth_;
+      return *this;
+    }
+
+    Viewport & setMaxDepth( float maxDepth_ )
+    {
+      maxDepth = maxDepth_;
+      return *this;
+    }
+
+    operator VkViewport const&() const
+    {
+      return *reinterpret_cast<const VkViewport*>( this );
+    }
+
+    operator VkViewport &()
+    {
+      return *reinterpret_cast<VkViewport*>( this );
+    }
+
+    bool operator==( Viewport const& rhs ) const
+    {
+      return ( x == rhs.x )
+          && ( y == rhs.y )
+          && ( width == rhs.width )
+          && ( height == rhs.height )
+          && ( minDepth == rhs.minDepth )
+          && ( maxDepth == rhs.maxDepth );
+    }
+
+    bool operator!=( Viewport const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    float x;
+    float y;
+    float width;
+    float height;
+    float minDepth;
+    float maxDepth;
+  };
+  static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" );
+
   struct PipelineViewportStateCreateInfo
   {
     PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_ = PipelineViewportStateCreateFlags(),
@@ -10631,8 +28572,7 @@ public:
       , pViewports( pViewports_ )
       , scissorCount( scissorCount_ )
       , pScissors( pScissors_ )
-    {
-    }
+    {}
 
     PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs )
     {
@@ -10644,37 +28584,38 @@ public:
       memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) );
       return *this;
     }
-    PipelineViewportStateCreateInfo& setPNext( const void* pNext_ )
+
+    PipelineViewportStateCreateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PipelineViewportStateCreateInfo& setFlags( PipelineViewportStateCreateFlags flags_ )
+    PipelineViewportStateCreateInfo & setFlags( PipelineViewportStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineViewportStateCreateInfo& setViewportCount( uint32_t viewportCount_ )
+    PipelineViewportStateCreateInfo & setViewportCount( uint32_t viewportCount_ )
     {
       viewportCount = viewportCount_;
       return *this;
     }
 
-    PipelineViewportStateCreateInfo& setPViewports( const Viewport* pViewports_ )
+    PipelineViewportStateCreateInfo & setPViewports( const Viewport* pViewports_ )
     {
       pViewports = pViewports_;
       return *this;
     }
 
-    PipelineViewportStateCreateInfo& setScissorCount( uint32_t scissorCount_ )
+    PipelineViewportStateCreateInfo & setScissorCount( uint32_t scissorCount_ )
     {
       scissorCount = scissorCount_;
       return *this;
     }
 
-    PipelineViewportStateCreateInfo& setPScissors( const Rect2D* pScissors_ )
+    PipelineViewportStateCreateInfo & setPScissors( const Rect2D* pScissors_ )
     {
       pScissors = pScissors_;
       return *this;
@@ -10682,12 +28623,12 @@ public:
 
     operator VkPipelineViewportStateCreateInfo const&() const
     {
-      return *reinterpret_cast<const VkPipelineViewportStateCreateInfo*>(this);
+      return *reinterpret_cast<const VkPipelineViewportStateCreateInfo*>( this );
     }
 
     operator VkPipelineViewportStateCreateInfo &()
     {
-      return *reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this);
+      return *reinterpret_cast<VkPipelineViewportStateCreateInfo*>( this );
     }
 
     bool operator==( PipelineViewportStateCreateInfo const& rhs ) const
@@ -10743,8 +28684,7 @@ public:
       , depthBiasClamp( depthBiasClamp_ )
       , depthBiasSlopeFactor( depthBiasSlopeFactor_ )
       , lineWidth( lineWidth_ )
-    {
-    }
+    {}
 
     PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs )
     {
@@ -10756,73 +28696,74 @@ public:
       memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) );
       return *this;
     }
-    PipelineRasterizationStateCreateInfo& setPNext( const void* pNext_ )
+
+    PipelineRasterizationStateCreateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo& setFlags( PipelineRasterizationStateCreateFlags flags_ )
+    PipelineRasterizationStateCreateInfo & setFlags( PipelineRasterizationStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo& setDepthClampEnable( Bool32 depthClampEnable_ )
+    PipelineRasterizationStateCreateInfo & setDepthClampEnable( Bool32 depthClampEnable_ )
     {
       depthClampEnable = depthClampEnable_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo& setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable_ )
+    PipelineRasterizationStateCreateInfo & setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable_ )
     {
       rasterizerDiscardEnable = rasterizerDiscardEnable_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo& setPolygonMode( PolygonMode polygonMode_ )
+    PipelineRasterizationStateCreateInfo & setPolygonMode( PolygonMode polygonMode_ )
     {
       polygonMode = polygonMode_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo& setCullMode( CullModeFlags cullMode_ )
+    PipelineRasterizationStateCreateInfo & setCullMode( CullModeFlags cullMode_ )
     {
       cullMode = cullMode_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo& setFrontFace( FrontFace frontFace_ )
+    PipelineRasterizationStateCreateInfo & setFrontFace( FrontFace frontFace_ )
     {
       frontFace = frontFace_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo& setDepthBiasEnable( Bool32 depthBiasEnable_ )
+    PipelineRasterizationStateCreateInfo & setDepthBiasEnable( Bool32 depthBiasEnable_ )
     {
       depthBiasEnable = depthBiasEnable_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo& setDepthBiasConstantFactor( float depthBiasConstantFactor_ )
+    PipelineRasterizationStateCreateInfo & setDepthBiasConstantFactor( float depthBiasConstantFactor_ )
     {
       depthBiasConstantFactor = depthBiasConstantFactor_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo& setDepthBiasClamp( float depthBiasClamp_ )
+    PipelineRasterizationStateCreateInfo & setDepthBiasClamp( float depthBiasClamp_ )
     {
       depthBiasClamp = depthBiasClamp_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo& setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ )
+    PipelineRasterizationStateCreateInfo & setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ )
     {
       depthBiasSlopeFactor = depthBiasSlopeFactor_;
       return *this;
     }
 
-    PipelineRasterizationStateCreateInfo& setLineWidth( float lineWidth_ )
+    PipelineRasterizationStateCreateInfo & setLineWidth( float lineWidth_ )
     {
       lineWidth = lineWidth_;
       return *this;
@@ -10830,12 +28771,12 @@ public:
 
     operator VkPipelineRasterizationStateCreateInfo const&() const
     {
-      return *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>(this);
+      return *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>( this );
     }
 
     operator VkPipelineRasterizationStateCreateInfo &()
     {
-      return *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>(this);
+      return *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>( this );
     }
 
     bool operator==( PipelineRasterizationStateCreateInfo const& rhs ) const
@@ -10879,6 +28820,233 @@ public:
   };
   static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "struct and wrapper have different size!" );
 
+  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 )
+      : flags( flags_ )
+      , rasterizationSamples( rasterizationSamples_ )
+      , sampleShadingEnable( sampleShadingEnable_ )
+      , minSampleShading( minSampleShading_ )
+      , pSampleMask( pSampleMask_ )
+      , alphaToCoverageEnable( alphaToCoverageEnable_ )
+      , alphaToOneEnable( alphaToOneEnable_ )
+    {}
+
+    PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
+    }
+
+    PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
+      return *this;
+    }
+
+    PipelineMultisampleStateCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineMultisampleStateCreateInfo & setFlags( PipelineMultisampleStateCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    PipelineMultisampleStateCreateInfo & setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ )
+    {
+      rasterizationSamples = rasterizationSamples_;
+      return *this;
+    }
+
+    PipelineMultisampleStateCreateInfo & setSampleShadingEnable( Bool32 sampleShadingEnable_ )
+    {
+      sampleShadingEnable = sampleShadingEnable_;
+      return *this;
+    }
+
+    PipelineMultisampleStateCreateInfo & setMinSampleShading( float minSampleShading_ )
+    {
+      minSampleShading = minSampleShading_;
+      return *this;
+    }
+
+    PipelineMultisampleStateCreateInfo & setPSampleMask( const SampleMask* pSampleMask_ )
+    {
+      pSampleMask = pSampleMask_;
+      return *this;
+    }
+
+    PipelineMultisampleStateCreateInfo & setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ )
+    {
+      alphaToCoverageEnable = alphaToCoverageEnable_;
+      return *this;
+    }
+
+    PipelineMultisampleStateCreateInfo & setAlphaToOneEnable( Bool32 alphaToOneEnable_ )
+    {
+      alphaToOneEnable = alphaToOneEnable_;
+      return *this;
+    }
+
+    operator VkPipelineMultisampleStateCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>( this );
+    }
+
+    operator VkPipelineMultisampleStateCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>( this );
+    }
+
+    bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( rasterizationSamples == rhs.rasterizationSamples )
+          && ( sampleShadingEnable == rhs.sampleShadingEnable )
+          && ( minSampleShading == rhs.minSampleShading )
+          && ( pSampleMask == rhs.pSampleMask )
+          && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable )
+          && ( alphaToOneEnable == rhs.alphaToOneEnable );
+    }
+
+    bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    PipelineMultisampleStateCreateFlags flags;
+    SampleCountFlagBits rasterizationSamples;
+    Bool32 sampleShadingEnable;
+    float minSampleShading;
+    const SampleMask* pSampleMask;
+    Bool32 alphaToCoverageEnable;
+    Bool32 alphaToOneEnable;
+  };
+  static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" );
+
+  struct StencilOpState
+  {
+    StencilOpState( StencilOp failOp_ = StencilOp::eKeep,
+                    StencilOp passOp_ = StencilOp::eKeep,
+                    StencilOp depthFailOp_ = StencilOp::eKeep,
+                    CompareOp compareOp_ = CompareOp::eNever,
+                    uint32_t compareMask_ = 0,
+                    uint32_t writeMask_ = 0,
+                    uint32_t reference_ = 0 )
+      : failOp( failOp_ )
+      , passOp( passOp_ )
+      , depthFailOp( depthFailOp_ )
+      , compareOp( compareOp_ )
+      , compareMask( compareMask_ )
+      , writeMask( writeMask_ )
+      , reference( reference_ )
+    {}
+
+    StencilOpState( VkStencilOpState const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( StencilOpState ) );
+    }
+
+    StencilOpState& operator=( VkStencilOpState const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( StencilOpState ) );
+      return *this;
+    }
+
+    StencilOpState & setFailOp( StencilOp failOp_ )
+    {
+      failOp = failOp_;
+      return *this;
+    }
+
+    StencilOpState & setPassOp( StencilOp passOp_ )
+    {
+      passOp = passOp_;
+      return *this;
+    }
+
+    StencilOpState & setDepthFailOp( StencilOp depthFailOp_ )
+    {
+      depthFailOp = depthFailOp_;
+      return *this;
+    }
+
+    StencilOpState & setCompareOp( CompareOp compareOp_ )
+    {
+      compareOp = compareOp_;
+      return *this;
+    }
+
+    StencilOpState & setCompareMask( uint32_t compareMask_ )
+    {
+      compareMask = compareMask_;
+      return *this;
+    }
+
+    StencilOpState & setWriteMask( uint32_t writeMask_ )
+    {
+      writeMask = writeMask_;
+      return *this;
+    }
+
+    StencilOpState & setReference( uint32_t reference_ )
+    {
+      reference = reference_;
+      return *this;
+    }
+
+    operator VkStencilOpState const&() const
+    {
+      return *reinterpret_cast<const VkStencilOpState*>( this );
+    }
+
+    operator VkStencilOpState &()
+    {
+      return *reinterpret_cast<VkStencilOpState*>( this );
+    }
+
+    bool operator==( StencilOpState const& rhs ) const
+    {
+      return ( failOp == rhs.failOp )
+          && ( passOp == rhs.passOp )
+          && ( depthFailOp == rhs.depthFailOp )
+          && ( compareOp == rhs.compareOp )
+          && ( compareMask == rhs.compareMask )
+          && ( writeMask == rhs.writeMask )
+          && ( reference == rhs.reference );
+    }
+
+    bool operator!=( StencilOpState const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    StencilOp failOp;
+    StencilOp passOp;
+    StencilOp depthFailOp;
+    CompareOp compareOp;
+    uint32_t compareMask;
+    uint32_t writeMask;
+    uint32_t reference;
+  };
+  static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" );
+
   struct PipelineDepthStencilStateCreateInfo
   {
     PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateFlags flags_ = PipelineDepthStencilStateCreateFlags(),
@@ -10901,8 +29069,7 @@ public:
       , back( back_ )
       , minDepthBounds( minDepthBounds_ )
       , maxDepthBounds( maxDepthBounds_ )
-    {
-    }
+    {}
 
     PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs )
     {
@@ -10914,67 +29081,68 @@ public:
       memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) );
       return *this;
     }
-    PipelineDepthStencilStateCreateInfo& setPNext( const void* pNext_ )
+
+    PipelineDepthStencilStateCreateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo& setFlags( PipelineDepthStencilStateCreateFlags flags_ )
+    PipelineDepthStencilStateCreateInfo & setFlags( PipelineDepthStencilStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo& setDepthTestEnable( Bool32 depthTestEnable_ )
+    PipelineDepthStencilStateCreateInfo & setDepthTestEnable( Bool32 depthTestEnable_ )
     {
       depthTestEnable = depthTestEnable_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo& setDepthWriteEnable( Bool32 depthWriteEnable_ )
+    PipelineDepthStencilStateCreateInfo & setDepthWriteEnable( Bool32 depthWriteEnable_ )
     {
       depthWriteEnable = depthWriteEnable_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo& setDepthCompareOp( CompareOp depthCompareOp_ )
+    PipelineDepthStencilStateCreateInfo & setDepthCompareOp( CompareOp depthCompareOp_ )
     {
       depthCompareOp = depthCompareOp_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo& setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable_ )
+    PipelineDepthStencilStateCreateInfo & setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable_ )
     {
       depthBoundsTestEnable = depthBoundsTestEnable_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo& setStencilTestEnable( Bool32 stencilTestEnable_ )
+    PipelineDepthStencilStateCreateInfo & setStencilTestEnable( Bool32 stencilTestEnable_ )
     {
       stencilTestEnable = stencilTestEnable_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo& setFront( StencilOpState front_ )
+    PipelineDepthStencilStateCreateInfo & setFront( StencilOpState front_ )
     {
       front = front_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo& setBack( StencilOpState back_ )
+    PipelineDepthStencilStateCreateInfo & setBack( StencilOpState back_ )
     {
       back = back_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo& setMinDepthBounds( float minDepthBounds_ )
+    PipelineDepthStencilStateCreateInfo & setMinDepthBounds( float minDepthBounds_ )
     {
       minDepthBounds = minDepthBounds_;
       return *this;
     }
 
-    PipelineDepthStencilStateCreateInfo& setMaxDepthBounds( float maxDepthBounds_ )
+    PipelineDepthStencilStateCreateInfo & setMaxDepthBounds( float maxDepthBounds_ )
     {
       maxDepthBounds = maxDepthBounds_;
       return *this;
@@ -10982,12 +29150,12 @@ public:
 
     operator VkPipelineDepthStencilStateCreateInfo const&() const
     {
-      return *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>(this);
+      return *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>( this );
     }
 
     operator VkPipelineDepthStencilStateCreateInfo &()
     {
-      return *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this);
+      return *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>( this );
     }
 
     bool operator==( PipelineDepthStencilStateCreateInfo const& rhs ) const
@@ -11029,3845 +29197,590 @@ public:
   };
   static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "struct and wrapper have different size!" );
 
-  struct PipelineCacheCreateInfo
+  struct PipelineColorBlendAttachmentState
   {
-    PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = PipelineCacheCreateFlags(),
-                             size_t initialDataSize_ = 0,
-                             const void* pInitialData_ = nullptr )
+    PipelineColorBlendAttachmentState( Bool32 blendEnable_ = 0,
+                                       BlendFactor srcColorBlendFactor_ = BlendFactor::eZero,
+                                       BlendFactor dstColorBlendFactor_ = BlendFactor::eZero,
+                                       BlendOp colorBlendOp_ = BlendOp::eAdd,
+                                       BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero,
+                                       BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero,
+                                       BlendOp alphaBlendOp_ = BlendOp::eAdd,
+                                       ColorComponentFlags colorWriteMask_ = ColorComponentFlags() )
+      : blendEnable( blendEnable_ )
+      , srcColorBlendFactor( srcColorBlendFactor_ )
+      , dstColorBlendFactor( dstColorBlendFactor_ )
+      , colorBlendOp( colorBlendOp_ )
+      , srcAlphaBlendFactor( srcAlphaBlendFactor_ )
+      , dstAlphaBlendFactor( dstAlphaBlendFactor_ )
+      , alphaBlendOp( alphaBlendOp_ )
+      , colorWriteMask( colorWriteMask_ )
+    {}
+
+    PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
+    }
+
+    PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
+      return *this;
+    }
+
+    PipelineColorBlendAttachmentState & setBlendEnable( Bool32 blendEnable_ )
+    {
+      blendEnable = blendEnable_;
+      return *this;
+    }
+
+    PipelineColorBlendAttachmentState & setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ )
+    {
+      srcColorBlendFactor = srcColorBlendFactor_;
+      return *this;
+    }
+
+    PipelineColorBlendAttachmentState & setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ )
+    {
+      dstColorBlendFactor = dstColorBlendFactor_;
+      return *this;
+    }
+
+    PipelineColorBlendAttachmentState & setColorBlendOp( BlendOp colorBlendOp_ )
+    {
+      colorBlendOp = colorBlendOp_;
+      return *this;
+    }
+
+    PipelineColorBlendAttachmentState & setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ )
+    {
+      srcAlphaBlendFactor = srcAlphaBlendFactor_;
+      return *this;
+    }
+
+    PipelineColorBlendAttachmentState & setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ )
+    {
+      dstAlphaBlendFactor = dstAlphaBlendFactor_;
+      return *this;
+    }
+
+    PipelineColorBlendAttachmentState & setAlphaBlendOp( BlendOp alphaBlendOp_ )
+    {
+      alphaBlendOp = alphaBlendOp_;
+      return *this;
+    }
+
+    PipelineColorBlendAttachmentState & setColorWriteMask( ColorComponentFlags colorWriteMask_ )
+    {
+      colorWriteMask = colorWriteMask_;
+      return *this;
+    }
+
+    operator VkPipelineColorBlendAttachmentState const&() const
+    {
+      return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>( this );
+    }
+
+    operator VkPipelineColorBlendAttachmentState &()
+    {
+      return *reinterpret_cast<VkPipelineColorBlendAttachmentState*>( this );
+    }
+
+    bool operator==( PipelineColorBlendAttachmentState const& rhs ) const
+    {
+      return ( blendEnable == rhs.blendEnable )
+          && ( srcColorBlendFactor == rhs.srcColorBlendFactor )
+          && ( dstColorBlendFactor == rhs.dstColorBlendFactor )
+          && ( colorBlendOp == rhs.colorBlendOp )
+          && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor )
+          && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor )
+          && ( alphaBlendOp == rhs.alphaBlendOp )
+          && ( colorWriteMask == rhs.colorWriteMask );
+    }
+
+    bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    Bool32 blendEnable;
+    BlendFactor srcColorBlendFactor;
+    BlendFactor dstColorBlendFactor;
+    BlendOp colorBlendOp;
+    BlendFactor srcAlphaBlendFactor;
+    BlendFactor dstAlphaBlendFactor;
+    BlendOp alphaBlendOp;
+    ColorComponentFlags colorWriteMask;
+  };
+  static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" );
+
+  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 } } )
       : flags( flags_ )
-      , initialDataSize( initialDataSize_ )
-      , pInitialData( pInitialData_ )
-    {
-    }
-
-    PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) );
-    }
-
-    PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) );
-      return *this;
-    }
-    PipelineCacheCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineCacheCreateInfo& setFlags( PipelineCacheCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineCacheCreateInfo& setInitialDataSize( size_t initialDataSize_ )
-    {
-      initialDataSize = initialDataSize_;
-      return *this;
-    }
-
-    PipelineCacheCreateInfo& setPInitialData( const void* pInitialData_ )
-    {
-      pInitialData = pInitialData_;
-      return *this;
-    }
-
-    operator VkPipelineCacheCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkPipelineCacheCreateInfo*>(this);
-    }
-
-    operator VkPipelineCacheCreateInfo &()
-    {
-      return *reinterpret_cast<VkPipelineCacheCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineCacheCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( initialDataSize == rhs.initialDataSize )
-          && ( pInitialData == rhs.pInitialData );
-    }
-
-    bool operator!=( PipelineCacheCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineCacheCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCacheCreateFlags flags;
-    size_t initialDataSize;
-    const void* pInitialData;
-  };
-  static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" );
-
-  struct CommandBufferAllocateInfo
-  {
-    CommandBufferAllocateInfo( CommandPool commandPool_ = CommandPool(),
-                               CommandBufferLevel level_ = CommandBufferLevel::ePrimary,
-                               uint32_t commandBufferCount_ = 0 )
-      : commandPool( commandPool_ )
-      , level( level_ )
-      , commandBufferCount( commandBufferCount_ )
-    {
-    }
-
-    CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) );
-    }
-
-    CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) );
-      return *this;
-    }
-    CommandBufferAllocateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CommandBufferAllocateInfo& setCommandPool( CommandPool commandPool_ )
-    {
-      commandPool = commandPool_;
-      return *this;
-    }
-
-    CommandBufferAllocateInfo& setLevel( CommandBufferLevel level_ )
-    {
-      level = level_;
-      return *this;
-    }
-
-    CommandBufferAllocateInfo& setCommandBufferCount( uint32_t commandBufferCount_ )
-    {
-      commandBufferCount = commandBufferCount_;
-      return *this;
-    }
-
-    operator VkCommandBufferAllocateInfo const&() const
-    {
-      return *reinterpret_cast<const VkCommandBufferAllocateInfo*>(this);
-    }
-
-    operator VkCommandBufferAllocateInfo &()
-    {
-      return *reinterpret_cast<VkCommandBufferAllocateInfo*>(this);
-    }
-
-    bool operator==( CommandBufferAllocateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( commandPool == rhs.commandPool )
-          && ( level == rhs.level )
-          && ( commandBufferCount == rhs.commandBufferCount );
-    }
-
-    bool operator!=( CommandBufferAllocateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCommandBufferAllocateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    CommandPool commandPool;
-    CommandBufferLevel level;
-    uint32_t commandBufferCount;
-  };
-  static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" );
-
-  struct RenderPassBeginInfo
-  {
-    RenderPassBeginInfo( RenderPass renderPass_ = RenderPass(),
-                         Framebuffer framebuffer_ = Framebuffer(),
-                         Rect2D renderArea_ = Rect2D(),
-                         uint32_t clearValueCount_ = 0,
-                         const ClearValue* pClearValues_ = nullptr )
-      : renderPass( renderPass_ )
-      , framebuffer( framebuffer_ )
-      , renderArea( renderArea_ )
-      , clearValueCount( clearValueCount_ )
-      , pClearValues( pClearValues_ )
-    {
-    }
-
-    RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) );
-    }
-
-    RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) );
-      return *this;
-    }
-    RenderPassBeginInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    RenderPassBeginInfo& setRenderPass( RenderPass renderPass_ )
-    {
-      renderPass = renderPass_;
-      return *this;
-    }
-
-    RenderPassBeginInfo& setFramebuffer( Framebuffer framebuffer_ )
-    {
-      framebuffer = framebuffer_;
-      return *this;
-    }
-
-    RenderPassBeginInfo& setRenderArea( Rect2D renderArea_ )
-    {
-      renderArea = renderArea_;
-      return *this;
-    }
-
-    RenderPassBeginInfo& setClearValueCount( uint32_t clearValueCount_ )
-    {
-      clearValueCount = clearValueCount_;
-      return *this;
-    }
-
-    RenderPassBeginInfo& setPClearValues( const ClearValue* pClearValues_ )
-    {
-      pClearValues = pClearValues_;
-      return *this;
-    }
-
-    operator VkRenderPassBeginInfo const&() const
-    {
-      return *reinterpret_cast<const VkRenderPassBeginInfo*>(this);
-    }
-
-    operator VkRenderPassBeginInfo &()
-    {
-      return *reinterpret_cast<VkRenderPassBeginInfo*>(this);
-    }
-
-    bool operator==( RenderPassBeginInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( renderPass == rhs.renderPass )
-          && ( framebuffer == rhs.framebuffer )
-          && ( renderArea == rhs.renderArea )
-          && ( clearValueCount == rhs.clearValueCount )
-          && ( pClearValues == rhs.pClearValues );
-    }
-
-    bool operator!=( RenderPassBeginInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eRenderPassBeginInfo;
-
-  public:
-    const void* pNext = nullptr;
-    RenderPass renderPass;
-    Framebuffer framebuffer;
-    Rect2D renderArea;
-    uint32_t clearValueCount;
-    const ClearValue* pClearValues;
-  };
-  static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" );
-
-  struct EventCreateInfo
-  {
-    EventCreateInfo( EventCreateFlags flags_ = EventCreateFlags() )
-      : flags( flags_ )
-    {
-    }
-
-    EventCreateInfo( VkEventCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( EventCreateInfo ) );
-    }
-
-    EventCreateInfo& operator=( VkEventCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( EventCreateInfo ) );
-      return *this;
-    }
-    EventCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    EventCreateInfo& setFlags( EventCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator VkEventCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkEventCreateInfo*>(this);
-    }
-
-    operator VkEventCreateInfo &()
-    {
-      return *reinterpret_cast<VkEventCreateInfo*>(this);
-    }
-
-    bool operator==( EventCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( EventCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eEventCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    EventCreateFlags flags;
-  };
-  static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" );
-
-  struct SemaphoreCreateInfo
-  {
-    SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = SemaphoreCreateFlags() )
-      : flags( flags_ )
-    {
-    }
-
-    SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) );
-    }
-
-    SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) );
-      return *this;
-    }
-    SemaphoreCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SemaphoreCreateInfo& setFlags( SemaphoreCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator VkSemaphoreCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkSemaphoreCreateInfo*>(this);
-    }
-
-    operator VkSemaphoreCreateInfo &()
-    {
-      return *reinterpret_cast<VkSemaphoreCreateInfo*>(this);
-    }
-
-    bool operator==( SemaphoreCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( SemaphoreCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSemaphoreCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    SemaphoreCreateFlags flags;
-  };
-  static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" );
-
-  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 )
-      : flags( flags_ )
-      , renderPass( renderPass_ )
+      , logicOpEnable( logicOpEnable_ )
+      , logicOp( logicOp_ )
       , attachmentCount( attachmentCount_ )
       , pAttachments( pAttachments_ )
-      , width( width_ )
-      , height( height_ )
-      , layers( layers_ )
     {
+      memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
     }
 
-    FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs )
+    PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs )
     {
-      memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) );
+      memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
     }
 
-    FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs )
+    PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs )
     {
-      memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) );
+      memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
       return *this;
     }
-    FramebufferCreateInfo& setPNext( const void* pNext_ )
+
+    PipelineColorBlendStateCreateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    FramebufferCreateInfo& setFlags( FramebufferCreateFlags flags_ )
+    PipelineColorBlendStateCreateInfo & setFlags( PipelineColorBlendStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    FramebufferCreateInfo& setRenderPass( RenderPass renderPass_ )
+    PipelineColorBlendStateCreateInfo & setLogicOpEnable( Bool32 logicOpEnable_ )
     {
-      renderPass = renderPass_;
+      logicOpEnable = logicOpEnable_;
       return *this;
     }
 
-    FramebufferCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
+    PipelineColorBlendStateCreateInfo & setLogicOp( LogicOp logicOp_ )
+    {
+      logicOp = logicOp_;
+      return *this;
+    }
+
+    PipelineColorBlendStateCreateInfo & setAttachmentCount( uint32_t attachmentCount_ )
     {
       attachmentCount = attachmentCount_;
       return *this;
     }
 
-    FramebufferCreateInfo& setPAttachments( const ImageView* pAttachments_ )
+    PipelineColorBlendStateCreateInfo & setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ )
     {
       pAttachments = pAttachments_;
       return *this;
     }
 
-    FramebufferCreateInfo& setWidth( uint32_t width_ )
+    PipelineColorBlendStateCreateInfo & setBlendConstants( std::array<float,4> blendConstants_ )
     {
-      width = width_;
+      memcpy( blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
       return *this;
     }
 
-    FramebufferCreateInfo& setHeight( uint32_t height_ )
+    operator VkPipelineColorBlendStateCreateInfo const&() const
     {
-      height = height_;
-      return *this;
+      return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>( this );
     }
 
-    FramebufferCreateInfo& setLayers( uint32_t layers_ )
+    operator VkPipelineColorBlendStateCreateInfo &()
     {
-      layers = layers_;
-      return *this;
+      return *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>( this );
     }
 
-    operator VkFramebufferCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkFramebufferCreateInfo*>(this);
-    }
-
-    operator VkFramebufferCreateInfo &()
-    {
-      return *reinterpret_cast<VkFramebufferCreateInfo*>(this);
-    }
-
-    bool operator==( FramebufferCreateInfo const& rhs ) const
+    bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
           && ( flags == rhs.flags )
-          && ( renderPass == rhs.renderPass )
+          && ( logicOpEnable == rhs.logicOpEnable )
+          && ( logicOp == rhs.logicOp )
           && ( attachmentCount == rhs.attachmentCount )
           && ( pAttachments == rhs.pAttachments )
-          && ( width == rhs.width )
-          && ( height == rhs.height )
-          && ( layers == rhs.layers );
+          && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 );
     }
 
-    bool operator!=( FramebufferCreateInfo const& rhs ) const
+    bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eFramebufferCreateInfo;
+    StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo;
 
   public:
     const void* pNext = nullptr;
-    FramebufferCreateFlags flags;
-    RenderPass renderPass;
+    PipelineColorBlendStateCreateFlags flags;
+    Bool32 logicOpEnable;
+    LogicOp logicOp;
     uint32_t attachmentCount;
-    const ImageView* pAttachments;
-    uint32_t width;
-    uint32_t height;
-    uint32_t layers;
+    const PipelineColorBlendAttachmentState* pAttachments;
+    float blendConstants[4];
   };
-  static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" );
 
-  struct DisplayModeCreateInfoKHR
+  struct PipelineDynamicStateCreateInfo
   {
-    DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = DisplayModeCreateFlagsKHR(),
-                              DisplayModeParametersKHR parameters_ = DisplayModeParametersKHR() )
+    PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(),
+                                    uint32_t dynamicStateCount_ = 0,
+                                    const DynamicState* pDynamicStates_ = nullptr )
       : flags( flags_ )
-      , parameters( parameters_ )
+      , dynamicStateCount( dynamicStateCount_ )
+      , pDynamicStates( pDynamicStates_ )
+    {}
+
+    PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
     }
 
-    DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs )
+    PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
     {
-      memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) );
-    }
-
-    DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) );
+      memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
       return *this;
     }
-    DisplayModeCreateInfoKHR& setPNext( const void* pNext_ )
+
+    PipelineDynamicStateCreateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    DisplayModeCreateInfoKHR& setFlags( DisplayModeCreateFlagsKHR flags_ )
+    PipelineDynamicStateCreateInfo & setFlags( PipelineDynamicStateCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    DisplayModeCreateInfoKHR& setParameters( DisplayModeParametersKHR parameters_ )
+    PipelineDynamicStateCreateInfo & setDynamicStateCount( uint32_t dynamicStateCount_ )
     {
-      parameters = parameters_;
+      dynamicStateCount = dynamicStateCount_;
       return *this;
     }
 
-    operator VkDisplayModeCreateInfoKHR const&() const
+    PipelineDynamicStateCreateInfo & setPDynamicStates( const DynamicState* pDynamicStates_ )
     {
-      return *reinterpret_cast<const VkDisplayModeCreateInfoKHR*>(this);
+      pDynamicStates = pDynamicStates_;
+      return *this;
     }
 
-    operator VkDisplayModeCreateInfoKHR &()
+    operator VkPipelineDynamicStateCreateInfo const&() const
     {
-      return *reinterpret_cast<VkDisplayModeCreateInfoKHR*>(this);
+      return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>( this );
     }
 
-    bool operator==( DisplayModeCreateInfoKHR const& rhs ) const
+    operator VkPipelineDynamicStateCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>( this );
+    }
+
+    bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
           && ( flags == rhs.flags )
-          && ( parameters == rhs.parameters );
+          && ( dynamicStateCount == rhs.dynamicStateCount )
+          && ( pDynamicStates == rhs.pDynamicStates );
     }
 
-    bool operator!=( DisplayModeCreateInfoKHR const& rhs ) const
+    bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eDisplayModeCreateInfoKHR;
+    StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
 
   public:
     const void* pNext = nullptr;
-    DisplayModeCreateFlagsKHR flags;
-    DisplayModeParametersKHR parameters;
+    PipelineDynamicStateCreateFlags flags;
+    uint32_t dynamicStateCount;
+    const DynamicState* pDynamicStates;
   };
-  static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
 
-  struct DisplayPresentInfoKHR
+  struct GraphicsPipelineCreateInfo
   {
-    DisplayPresentInfoKHR( Rect2D srcRect_ = Rect2D(),
-                           Rect2D dstRect_ = Rect2D(),
-                           Bool32 persistent_ = 0 )
-      : srcRect( srcRect_ )
-      , dstRect( dstRect_ )
-      , persistent( persistent_ )
-    {
-    }
-
-    DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) );
-    }
-
-    DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) );
-      return *this;
-    }
-    DisplayPresentInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DisplayPresentInfoKHR& setSrcRect( Rect2D srcRect_ )
-    {
-      srcRect = srcRect_;
-      return *this;
-    }
-
-    DisplayPresentInfoKHR& setDstRect( Rect2D dstRect_ )
-    {
-      dstRect = dstRect_;
-      return *this;
-    }
-
-    DisplayPresentInfoKHR& setPersistent( Bool32 persistent_ )
-    {
-      persistent = persistent_;
-      return *this;
-    }
-
-    operator VkDisplayPresentInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkDisplayPresentInfoKHR*>(this);
-    }
-
-    operator VkDisplayPresentInfoKHR &()
-    {
-      return *reinterpret_cast<VkDisplayPresentInfoKHR*>(this);
-    }
-
-    bool operator==( DisplayPresentInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( srcRect == rhs.srcRect )
-          && ( dstRect == rhs.dstRect )
-          && ( persistent == rhs.persistent );
-    }
-
-    bool operator!=( DisplayPresentInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDisplayPresentInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Rect2D srcRect;
-    Rect2D dstRect;
-    Bool32 persistent;
-  };
-  static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct AndroidSurfaceCreateInfoKHR
-  {
-    AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = AndroidSurfaceCreateFlagsKHR(),
-                                 struct ANativeWindow* window_ = nullptr )
+    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 )
       : flags( flags_ )
-      , window( window_ )
+      , stageCount( stageCount_ )
+      , pStages( pStages_ )
+      , pVertexInputState( pVertexInputState_ )
+      , pInputAssemblyState( pInputAssemblyState_ )
+      , pTessellationState( pTessellationState_ )
+      , pViewportState( pViewportState_ )
+      , pRasterizationState( pRasterizationState_ )
+      , pMultisampleState( pMultisampleState_ )
+      , pDepthStencilState( pDepthStencilState_ )
+      , pColorBlendState( pColorBlendState_ )
+      , pDynamicState( pDynamicState_ )
+      , layout( layout_ )
+      , renderPass( renderPass_ )
+      , subpass( subpass_ )
+      , basePipelineHandle( basePipelineHandle_ )
+      , basePipelineIndex( basePipelineIndex_ )
+    {}
+
+    GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs )
     {
+      memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
     }
 
-    AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs )
+    GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs )
     {
-      memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) );
-    }
-
-    AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) );
+      memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
       return *this;
     }
-    AndroidSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
+
+    GraphicsPipelineCreateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    AndroidSurfaceCreateInfoKHR& setFlags( AndroidSurfaceCreateFlagsKHR flags_ )
+    GraphicsPipelineCreateInfo & setFlags( PipelineCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    AndroidSurfaceCreateInfoKHR& setWindow( struct ANativeWindow* window_ )
+    GraphicsPipelineCreateInfo & setStageCount( uint32_t stageCount_ )
     {
-      window = window_;
+      stageCount = stageCount_;
       return *this;
     }
 
-    operator VkAndroidSurfaceCreateInfoKHR const&() const
+    GraphicsPipelineCreateInfo & setPStages( const PipelineShaderStageCreateInfo* pStages_ )
     {
-      return *reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>(this);
+      pStages = pStages_;
+      return *this;
     }
 
-    operator VkAndroidSurfaceCreateInfoKHR &()
+    GraphicsPipelineCreateInfo & setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ )
     {
-      return *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>(this);
+      pVertexInputState = pVertexInputState_;
+      return *this;
     }
 
-    bool operator==( AndroidSurfaceCreateInfoKHR const& rhs ) const
+    GraphicsPipelineCreateInfo & setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ )
+    {
+      pInputAssemblyState = pInputAssemblyState_;
+      return *this;
+    }
+
+    GraphicsPipelineCreateInfo & setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ )
+    {
+      pTessellationState = pTessellationState_;
+      return *this;
+    }
+
+    GraphicsPipelineCreateInfo & setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ )
+    {
+      pViewportState = pViewportState_;
+      return *this;
+    }
+
+    GraphicsPipelineCreateInfo & setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ )
+    {
+      pRasterizationState = pRasterizationState_;
+      return *this;
+    }
+
+    GraphicsPipelineCreateInfo & setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ )
+    {
+      pMultisampleState = pMultisampleState_;
+      return *this;
+    }
+
+    GraphicsPipelineCreateInfo & setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ )
+    {
+      pDepthStencilState = pDepthStencilState_;
+      return *this;
+    }
+
+    GraphicsPipelineCreateInfo & setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ )
+    {
+      pColorBlendState = pColorBlendState_;
+      return *this;
+    }
+
+    GraphicsPipelineCreateInfo & setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ )
+    {
+      pDynamicState = pDynamicState_;
+      return *this;
+    }
+
+    GraphicsPipelineCreateInfo & setLayout( PipelineLayout layout_ )
+    {
+      layout = layout_;
+      return *this;
+    }
+
+    GraphicsPipelineCreateInfo & setRenderPass( RenderPass renderPass_ )
+    {
+      renderPass = renderPass_;
+      return *this;
+    }
+
+    GraphicsPipelineCreateInfo & setSubpass( uint32_t subpass_ )
+    {
+      subpass = subpass_;
+      return *this;
+    }
+
+    GraphicsPipelineCreateInfo & setBasePipelineHandle( Pipeline basePipelineHandle_ )
+    {
+      basePipelineHandle = basePipelineHandle_;
+      return *this;
+    }
+
+    GraphicsPipelineCreateInfo & setBasePipelineIndex( int32_t basePipelineIndex_ )
+    {
+      basePipelineIndex = basePipelineIndex_;
+      return *this;
+    }
+
+    operator VkGraphicsPipelineCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( this );
+    }
+
+    operator VkGraphicsPipelineCreateInfo &()
+    {
+      return *reinterpret_cast<VkGraphicsPipelineCreateInfo*>( this );
+    }
+
+    bool operator==( GraphicsPipelineCreateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
           && ( flags == rhs.flags )
-          && ( window == rhs.window );
+          && ( stageCount == rhs.stageCount )
+          && ( pStages == rhs.pStages )
+          && ( pVertexInputState == rhs.pVertexInputState )
+          && ( pInputAssemblyState == rhs.pInputAssemblyState )
+          && ( pTessellationState == rhs.pTessellationState )
+          && ( pViewportState == rhs.pViewportState )
+          && ( pRasterizationState == rhs.pRasterizationState )
+          && ( pMultisampleState == rhs.pMultisampleState )
+          && ( pDepthStencilState == rhs.pDepthStencilState )
+          && ( pColorBlendState == rhs.pColorBlendState )
+          && ( pDynamicState == rhs.pDynamicState )
+          && ( layout == rhs.layout )
+          && ( renderPass == rhs.renderPass )
+          && ( subpass == rhs.subpass )
+          && ( basePipelineHandle == rhs.basePipelineHandle )
+          && ( basePipelineIndex == rhs.basePipelineIndex );
     }
 
-    bool operator!=( AndroidSurfaceCreateInfoKHR const& rhs ) const
+    bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR;
+    StructureType sType = StructureType::eGraphicsPipelineCreateInfo;
 
   public:
     const void* pNext = nullptr;
-    AndroidSurfaceCreateFlagsKHR flags;
-    struct ANativeWindow* window;
+    PipelineCreateFlags flags;
+    uint32_t stageCount;
+    const PipelineShaderStageCreateInfo* pStages;
+    const PipelineVertexInputStateCreateInfo* pVertexInputState;
+    const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
+    const PipelineTessellationStateCreateInfo* pTessellationState;
+    const PipelineViewportStateCreateInfo* pViewportState;
+    const PipelineRasterizationStateCreateInfo* pRasterizationState;
+    const PipelineMultisampleStateCreateInfo* pMultisampleState;
+    const PipelineDepthStencilStateCreateInfo* pDepthStencilState;
+    const PipelineColorBlendStateCreateInfo* pColorBlendState;
+    const PipelineDynamicStateCreateInfo* pDynamicState;
+    PipelineLayout layout;
+    RenderPass renderPass;
+    uint32_t subpass;
+    Pipeline basePipelineHandle;
+    int32_t basePipelineIndex;
   };
-  static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+  static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" );
 
-#ifdef VK_USE_PLATFORM_VI_NN
-  struct ViSurfaceCreateInfoNN
+  struct XYColorEXT
   {
-    ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = ViSurfaceCreateFlagsNN(),
-                           void* window_ = nullptr )
-      : flags( flags_ )
-      , window( window_ )
+    XYColorEXT( float x_ = 0,
+                float y_ = 0 )
+      : x( x_ )
+      , y( y_ )
+    {}
+
+    XYColorEXT( VkXYColorEXT const & rhs )
     {
+      memcpy( this, &rhs, sizeof( XYColorEXT ) );
     }
 
-    ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs )
+    XYColorEXT& operator=( VkXYColorEXT const & rhs )
     {
-      memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) );
-    }
-
-    ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) );
-      return *this;
-    }
-    ViSurfaceCreateInfoNN& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
+      memcpy( this, &rhs, sizeof( XYColorEXT ) );
       return *this;
     }
 
-    ViSurfaceCreateInfoNN& setFlags( ViSurfaceCreateFlagsNN flags_ )
+    XYColorEXT & setX( float x_ )
     {
-      flags = flags_;
+      x = x_;
       return *this;
     }
 
-    ViSurfaceCreateInfoNN& setWindow( void* window_ )
+    XYColorEXT & setY( float y_ )
     {
-      window = window_;
+      y = y_;
       return *this;
     }
 
-    operator VkViSurfaceCreateInfoNN const&() const
+    operator VkXYColorEXT const&() const
     {
-      return *reinterpret_cast<const VkViSurfaceCreateInfoNN*>(this);
+      return *reinterpret_cast<const VkXYColorEXT*>( this );
     }
 
-    operator VkViSurfaceCreateInfoNN &()
+    operator VkXYColorEXT &()
     {
-      return *reinterpret_cast<VkViSurfaceCreateInfoNN*>(this);
+      return *reinterpret_cast<VkXYColorEXT*>( this );
     }
 
-    bool operator==( ViSurfaceCreateInfoNN const& rhs ) const
+    bool operator==( XYColorEXT const& rhs ) const
     {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( window == rhs.window );
+      return ( x == rhs.x )
+          && ( y == rhs.y );
     }
 
-    bool operator!=( ViSurfaceCreateInfoNN const& rhs ) const
+    bool operator!=( XYColorEXT const& rhs ) const
     {
       return !operator==( rhs );
     }
 
-  private:
-    StructureType sType = StructureType::eViSurfaceCreateInfoNN;
-
-  public:
-    const void* pNext = nullptr;
-    ViSurfaceCreateFlagsNN flags;
-    void* window;
+    float x;
+    float y;
   };
-  static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  struct WaylandSurfaceCreateInfoKHR
-  {
-    WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = WaylandSurfaceCreateFlagsKHR(),
-                                 struct wl_display* display_ = nullptr,
-                                 struct wl_surface* surface_ = nullptr )
-      : flags( flags_ )
-      , display( display_ )
-      , surface( surface_ )
-    {
-    }
-
-    WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) );
-    }
-
-    WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) );
-      return *this;
-    }
-    WaylandSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    WaylandSurfaceCreateInfoKHR& setFlags( WaylandSurfaceCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    WaylandSurfaceCreateInfoKHR& setDisplay( struct wl_display* display_ )
-    {
-      display = display_;
-      return *this;
-    }
-
-    WaylandSurfaceCreateInfoKHR& setSurface( struct wl_surface* surface_ )
-    {
-      surface = surface_;
-      return *this;
-    }
-
-    operator VkWaylandSurfaceCreateInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>(this);
-    }
-
-    operator VkWaylandSurfaceCreateInfoKHR &()
-    {
-      return *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>(this);
-    }
-
-    bool operator==( WaylandSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( display == rhs.display )
-          && ( surface == rhs.surface );
-    }
-
-    bool operator!=( WaylandSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    WaylandSurfaceCreateFlagsKHR flags;
-    struct wl_display* display;
-    struct wl_surface* surface;
-  };
-  static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct Win32SurfaceCreateInfoKHR
-  {
-    Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = Win32SurfaceCreateFlagsKHR(),
-                               HINSTANCE hinstance_ = 0,
-                               HWND hwnd_ = 0 )
-      : flags( flags_ )
-      , hinstance( hinstance_ )
-      , hwnd( hwnd_ )
-    {
-    }
-
-    Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) );
-    }
-
-    Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) );
-      return *this;
-    }
-    Win32SurfaceCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    Win32SurfaceCreateInfoKHR& setFlags( Win32SurfaceCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    Win32SurfaceCreateInfoKHR& setHinstance( HINSTANCE hinstance_ )
-    {
-      hinstance = hinstance_;
-      return *this;
-    }
-
-    Win32SurfaceCreateInfoKHR& setHwnd( HWND hwnd_ )
-    {
-      hwnd = hwnd_;
-      return *this;
-    }
-
-    operator VkWin32SurfaceCreateInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>(this);
-    }
-
-    operator VkWin32SurfaceCreateInfoKHR &()
-    {
-      return *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>(this);
-    }
-
-    bool operator==( Win32SurfaceCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( hinstance == rhs.hinstance )
-          && ( hwnd == rhs.hwnd );
-    }
-
-    bool operator!=( Win32SurfaceCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Win32SurfaceCreateFlagsKHR flags;
-    HINSTANCE hinstance;
-    HWND hwnd;
-  };
-  static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  struct XlibSurfaceCreateInfoKHR
-  {
-    XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = XlibSurfaceCreateFlagsKHR(),
-                              Display* dpy_ = nullptr,
-                              Window window_ = 0 )
-      : flags( flags_ )
-      , dpy( dpy_ )
-      , window( window_ )
-    {
-    }
-
-    XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) );
-    }
-
-    XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) );
-      return *this;
-    }
-    XlibSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    XlibSurfaceCreateInfoKHR& setFlags( XlibSurfaceCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    XlibSurfaceCreateInfoKHR& setDpy( Display* dpy_ )
-    {
-      dpy = dpy_;
-      return *this;
-    }
-
-    XlibSurfaceCreateInfoKHR& setWindow( Window window_ )
-    {
-      window = window_;
-      return *this;
-    }
-
-    operator VkXlibSurfaceCreateInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>(this);
-    }
-
-    operator VkXlibSurfaceCreateInfoKHR &()
-    {
-      return *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>(this);
-    }
-
-    bool operator==( XlibSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( dpy == rhs.dpy )
-          && ( window == rhs.window );
-    }
-
-    bool operator!=( XlibSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    XlibSurfaceCreateFlagsKHR flags;
-    Display* dpy;
-    Window window;
-  };
-  static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  struct XcbSurfaceCreateInfoKHR
-  {
-    XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = XcbSurfaceCreateFlagsKHR(),
-                             xcb_connection_t* connection_ = nullptr,
-                             xcb_window_t window_ = 0 )
-      : flags( flags_ )
-      , connection( connection_ )
-      , window( window_ )
-    {
-    }
-
-    XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) );
-    }
-
-    XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) );
-      return *this;
-    }
-    XcbSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    XcbSurfaceCreateInfoKHR& setFlags( XcbSurfaceCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    XcbSurfaceCreateInfoKHR& setConnection( xcb_connection_t* connection_ )
-    {
-      connection = connection_;
-      return *this;
-    }
-
-    XcbSurfaceCreateInfoKHR& setWindow( xcb_window_t window_ )
-    {
-      window = window_;
-      return *this;
-    }
-
-    operator VkXcbSurfaceCreateInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>(this);
-    }
-
-    operator VkXcbSurfaceCreateInfoKHR &()
-    {
-      return *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>(this);
-    }
-
-    bool operator==( XcbSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( connection == rhs.connection )
-          && ( window == rhs.window );
-    }
-
-    bool operator!=( XcbSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    XcbSurfaceCreateFlagsKHR flags;
-    xcb_connection_t* connection;
-    xcb_window_t window;
-  };
-  static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#ifdef VK_USE_PLATFORM_FUCHSIA
-  struct ImagePipeSurfaceCreateInfoFUCHSIA
-  {
-    ImagePipeSurfaceCreateInfoFUCHSIA( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = ImagePipeSurfaceCreateFlagsFUCHSIA(),
-                                       zx_handle_t imagePipeHandle_ = 0 )
-      : flags( flags_ )
-      , imagePipeHandle( imagePipeHandle_ )
-    {
-    }
-
-    ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) );
-    }
-
-    ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) );
-      return *this;
-    }
-    ImagePipeSurfaceCreateInfoFUCHSIA& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImagePipeSurfaceCreateInfoFUCHSIA& setFlags( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ImagePipeSurfaceCreateInfoFUCHSIA& setImagePipeHandle( zx_handle_t imagePipeHandle_ )
-    {
-      imagePipeHandle = imagePipeHandle_;
-      return *this;
-    }
-
-    operator VkImagePipeSurfaceCreateInfoFUCHSIA const&() const
-    {
-      return *reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>(this);
-    }
-
-    operator VkImagePipeSurfaceCreateInfoFUCHSIA &()
-    {
-      return *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>(this);
-    }
-
-    bool operator==( ImagePipeSurfaceCreateInfoFUCHSIA const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( imagePipeHandle == rhs.imagePipeHandle );
-    }
-
-    bool operator!=( ImagePipeSurfaceCreateInfoFUCHSIA const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA;
-
-  public:
-    const void* pNext = nullptr;
-    ImagePipeSurfaceCreateFlagsFUCHSIA flags;
-    zx_handle_t imagePipeHandle;
-  };
-  static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-  struct DebugMarkerMarkerInfoEXT
-  {
-    DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr,
-                              std::array<float,4> const& color_ = { { 0, 0, 0, 0 } } )
-      : pMarkerName( pMarkerName_ )
-    {
-      memcpy( &color, color_.data(), 4 * sizeof( float ) );
-    }
-
-    DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) );
-    }
-
-    DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) );
-      return *this;
-    }
-    DebugMarkerMarkerInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DebugMarkerMarkerInfoEXT& setPMarkerName( const char* pMarkerName_ )
-    {
-      pMarkerName = pMarkerName_;
-      return *this;
-    }
-
-    DebugMarkerMarkerInfoEXT& setColor( std::array<float,4> color_ )
-    {
-      memcpy( &color, color_.data(), 4 * sizeof( float ) );
-      return *this;
-    }
-
-    operator VkDebugMarkerMarkerInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>(this);
-    }
-
-    operator VkDebugMarkerMarkerInfoEXT &()
-    {
-      return *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(this);
-    }
-
-    bool operator==( DebugMarkerMarkerInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pMarkerName == rhs.pMarkerName )
-          && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 );
-    }
-
-    bool operator!=( DebugMarkerMarkerInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    const char* pMarkerName;
-    float color[4];
-  };
-  static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" );
-
-  struct DedicatedAllocationImageCreateInfoNV
-  {
-    DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
-      : dedicatedAllocation( dedicatedAllocation_ )
-    {
-    }
-
-    DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) );
-    }
-
-    DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) );
-      return *this;
-    }
-    DedicatedAllocationImageCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DedicatedAllocationImageCreateInfoNV& setDedicatedAllocation( Bool32 dedicatedAllocation_ )
-    {
-      dedicatedAllocation = dedicatedAllocation_;
-      return *this;
-    }
-
-    operator VkDedicatedAllocationImageCreateInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(this);
-    }
-
-    operator VkDedicatedAllocationImageCreateInfoNV &()
-    {
-      return *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(this);
-    }
-
-    bool operator==( DedicatedAllocationImageCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( dedicatedAllocation == rhs.dedicatedAllocation );
-    }
-
-    bool operator!=( DedicatedAllocationImageCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 dedicatedAllocation;
-  };
-  static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" );
-
-  struct DedicatedAllocationBufferCreateInfoNV
-  {
-    DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
-      : dedicatedAllocation( dedicatedAllocation_ )
-    {
-    }
-
-    DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) );
-    }
-
-    DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) );
-      return *this;
-    }
-    DedicatedAllocationBufferCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DedicatedAllocationBufferCreateInfoNV& setDedicatedAllocation( Bool32 dedicatedAllocation_ )
-    {
-      dedicatedAllocation = dedicatedAllocation_;
-      return *this;
-    }
-
-    operator VkDedicatedAllocationBufferCreateInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(this);
-    }
-
-    operator VkDedicatedAllocationBufferCreateInfoNV &()
-    {
-      return *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(this);
-    }
-
-    bool operator==( DedicatedAllocationBufferCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( dedicatedAllocation == rhs.dedicatedAllocation );
-    }
-
-    bool operator!=( DedicatedAllocationBufferCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 dedicatedAllocation;
-  };
-  static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" );
-
-  struct DedicatedAllocationMemoryAllocateInfoNV
-  {
-    DedicatedAllocationMemoryAllocateInfoNV( Image image_ = Image(),
-                                             Buffer buffer_ = Buffer() )
-      : image( image_ )
-      , buffer( buffer_ )
-    {
-    }
-
-    DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) );
-    }
-
-    DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) );
-      return *this;
-    }
-    DedicatedAllocationMemoryAllocateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DedicatedAllocationMemoryAllocateInfoNV& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    DedicatedAllocationMemoryAllocateInfoNV& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    operator VkDedicatedAllocationMemoryAllocateInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(this);
-    }
-
-    operator VkDedicatedAllocationMemoryAllocateInfoNV &()
-    {
-      return *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(this);
-    }
-
-    bool operator==( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( image == rhs.image )
-          && ( buffer == rhs.buffer );
-    }
-
-    bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
-    Buffer buffer;
-  };
-  static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ExportMemoryWin32HandleInfoNV
-  {
-    ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
-                                   DWORD dwAccess_ = 0 )
-      : pAttributes( pAttributes_ )
-      , dwAccess( dwAccess_ )
-    {
-    }
-
-    ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) );
-    }
-
-    ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) );
-      return *this;
-    }
-    ExportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportMemoryWin32HandleInfoNV& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
-    {
-      pAttributes = pAttributes_;
-      return *this;
-    }
-
-    ExportMemoryWin32HandleInfoNV& setDwAccess( DWORD dwAccess_ )
-    {
-      dwAccess = dwAccess_;
-      return *this;
-    }
-
-    operator VkExportMemoryWin32HandleInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(this);
-    }
-
-    operator VkExportMemoryWin32HandleInfoNV &()
-    {
-      return *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(this);
-    }
-
-    bool operator==( ExportMemoryWin32HandleInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pAttributes == rhs.pAttributes )
-          && ( dwAccess == rhs.dwAccess );
-    }
-
-    bool operator!=( ExportMemoryWin32HandleInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    const SECURITY_ATTRIBUTES* pAttributes;
-    DWORD dwAccess;
-  };
-  static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  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 )
-      : acquireCount( acquireCount_ )
-      , pAcquireSyncs( pAcquireSyncs_ )
-      , pAcquireKeys( pAcquireKeys_ )
-      , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
-      , releaseCount( releaseCount_ )
-      , pReleaseSyncs( pReleaseSyncs_ )
-      , pReleaseKeys( pReleaseKeys_ )
-    {
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) );
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) );
-      return *this;
-    }
-    Win32KeyedMutexAcquireReleaseInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setAcquireCount( uint32_t acquireCount_ )
-    {
-      acquireCount = acquireCount_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
-    {
-      pAcquireSyncs = pAcquireSyncs_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireKeys( const uint64_t* pAcquireKeys_ )
-    {
-      pAcquireKeys = pAcquireKeys_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireTimeoutMilliseconds( const uint32_t* pAcquireTimeoutMilliseconds_ )
-    {
-      pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setReleaseCount( uint32_t releaseCount_ )
-    {
-      releaseCount = releaseCount_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
-    {
-      pReleaseSyncs = pReleaseSyncs_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseKeys( const uint64_t* pReleaseKeys_ )
-    {
-      pReleaseKeys = pReleaseKeys_;
-      return *this;
-    }
-
-    operator VkWin32KeyedMutexAcquireReleaseInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(this);
-    }
-
-    operator VkWin32KeyedMutexAcquireReleaseInfoNV &()
-    {
-      return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(this);
-    }
-
-    bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( acquireCount == rhs.acquireCount )
-          && ( pAcquireSyncs == rhs.pAcquireSyncs )
-          && ( pAcquireKeys == rhs.pAcquireKeys )
-          && ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds )
-          && ( releaseCount == rhs.releaseCount )
-          && ( pReleaseSyncs == rhs.pReleaseSyncs )
-          && ( pReleaseKeys == rhs.pReleaseKeys );
-    }
-
-    bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t acquireCount;
-    const DeviceMemory* pAcquireSyncs;
-    const uint64_t* pAcquireKeys;
-    const uint32_t* pAcquireTimeoutMilliseconds;
-    uint32_t releaseCount;
-    const DeviceMemory* pReleaseSyncs;
-    const uint64_t* pReleaseKeys;
-  };
-  static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct DeviceGeneratedCommandsFeaturesNVX
-  {
-    DeviceGeneratedCommandsFeaturesNVX( Bool32 computeBindingPointSupport_ = 0 )
-      : computeBindingPointSupport( computeBindingPointSupport_ )
-    {
-    }
-
-    DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) );
-    }
-
-    DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) );
-      return *this;
-    }
-    DeviceGeneratedCommandsFeaturesNVX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGeneratedCommandsFeaturesNVX& setComputeBindingPointSupport( Bool32 computeBindingPointSupport_ )
-    {
-      computeBindingPointSupport = computeBindingPointSupport_;
-      return *this;
-    }
-
-    operator VkDeviceGeneratedCommandsFeaturesNVX const&() const
-    {
-      return *reinterpret_cast<const VkDeviceGeneratedCommandsFeaturesNVX*>(this);
-    }
-
-    operator VkDeviceGeneratedCommandsFeaturesNVX &()
-    {
-      return *reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>(this);
-    }
-
-    bool operator==( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( computeBindingPointSupport == rhs.computeBindingPointSupport );
-    }
-
-    bool operator!=( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 computeBindingPointSupport;
-  };
-  static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" );
-
-  struct DeviceGeneratedCommandsLimitsNVX
-  {
-    DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0,
-                                      uint32_t maxObjectEntryCounts_ = 0,
-                                      uint32_t minSequenceCountBufferOffsetAlignment_ = 0,
-                                      uint32_t minSequenceIndexBufferOffsetAlignment_ = 0,
-                                      uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 )
-      : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
-      , maxObjectEntryCounts( maxObjectEntryCounts_ )
-      , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ )
-      , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ )
-      , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ )
-    {
-    }
-
-    DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) );
-    }
-
-    DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) );
-      return *this;
-    }
-    DeviceGeneratedCommandsLimitsNVX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGeneratedCommandsLimitsNVX& setMaxIndirectCommandsLayoutTokenCount( uint32_t maxIndirectCommandsLayoutTokenCount_ )
-    {
-      maxIndirectCommandsLayoutTokenCount = maxIndirectCommandsLayoutTokenCount_;
-      return *this;
-    }
-
-    DeviceGeneratedCommandsLimitsNVX& setMaxObjectEntryCounts( uint32_t maxObjectEntryCounts_ )
-    {
-      maxObjectEntryCounts = maxObjectEntryCounts_;
-      return *this;
-    }
-
-    DeviceGeneratedCommandsLimitsNVX& setMinSequenceCountBufferOffsetAlignment( uint32_t minSequenceCountBufferOffsetAlignment_ )
-    {
-      minSequenceCountBufferOffsetAlignment = minSequenceCountBufferOffsetAlignment_;
-      return *this;
-    }
-
-    DeviceGeneratedCommandsLimitsNVX& setMinSequenceIndexBufferOffsetAlignment( uint32_t minSequenceIndexBufferOffsetAlignment_ )
-    {
-      minSequenceIndexBufferOffsetAlignment = minSequenceIndexBufferOffsetAlignment_;
-      return *this;
-    }
-
-    DeviceGeneratedCommandsLimitsNVX& setMinCommandsTokenBufferOffsetAlignment( uint32_t minCommandsTokenBufferOffsetAlignment_ )
-    {
-      minCommandsTokenBufferOffsetAlignment = minCommandsTokenBufferOffsetAlignment_;
-      return *this;
-    }
-
-    operator VkDeviceGeneratedCommandsLimitsNVX const&() const
-    {
-      return *reinterpret_cast<const VkDeviceGeneratedCommandsLimitsNVX*>(this);
-    }
-
-    operator VkDeviceGeneratedCommandsLimitsNVX &()
-    {
-      return *reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>(this);
-    }
-
-    bool operator==( DeviceGeneratedCommandsLimitsNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxIndirectCommandsLayoutTokenCount == rhs.maxIndirectCommandsLayoutTokenCount )
-          && ( maxObjectEntryCounts == rhs.maxObjectEntryCounts )
-          && ( minSequenceCountBufferOffsetAlignment == rhs.minSequenceCountBufferOffsetAlignment )
-          && ( minSequenceIndexBufferOffsetAlignment == rhs.minSequenceIndexBufferOffsetAlignment )
-          && ( minCommandsTokenBufferOffsetAlignment == rhs.minCommandsTokenBufferOffsetAlignment );
-    }
-
-    bool operator!=( DeviceGeneratedCommandsLimitsNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t maxIndirectCommandsLayoutTokenCount;
-    uint32_t maxObjectEntryCounts;
-    uint32_t minSequenceCountBufferOffsetAlignment;
-    uint32_t minSequenceIndexBufferOffsetAlignment;
-    uint32_t minCommandsTokenBufferOffsetAlignment;
-  };
-  static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "struct and wrapper have different size!" );
-
-  struct CmdReserveSpaceForCommandsInfoNVX
-  {
-    CmdReserveSpaceForCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(),
-                                       IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(),
-                                       uint32_t maxSequencesCount_ = 0 )
-      : objectTable( objectTable_ )
-      , indirectCommandsLayout( indirectCommandsLayout_ )
-      , maxSequencesCount( maxSequencesCount_ )
-    {
-    }
-
-    CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) );
-    }
-
-    CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) );
-      return *this;
-    }
-    CmdReserveSpaceForCommandsInfoNVX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CmdReserveSpaceForCommandsInfoNVX& setObjectTable( ObjectTableNVX objectTable_ )
-    {
-      objectTable = objectTable_;
-      return *this;
-    }
-
-    CmdReserveSpaceForCommandsInfoNVX& setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ )
-    {
-      indirectCommandsLayout = indirectCommandsLayout_;
-      return *this;
-    }
-
-    CmdReserveSpaceForCommandsInfoNVX& setMaxSequencesCount( uint32_t maxSequencesCount_ )
-    {
-      maxSequencesCount = maxSequencesCount_;
-      return *this;
-    }
-
-    operator VkCmdReserveSpaceForCommandsInfoNVX const&() const
-    {
-      return *reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>(this);
-    }
-
-    operator VkCmdReserveSpaceForCommandsInfoNVX &()
-    {
-      return *reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX*>(this);
-    }
-
-    bool operator==( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( objectTable == rhs.objectTable )
-          && ( indirectCommandsLayout == rhs.indirectCommandsLayout )
-          && ( maxSequencesCount == rhs.maxSequencesCount );
-    }
-
-    bool operator!=( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX;
-
-  public:
-    const void* pNext = nullptr;
-    ObjectTableNVX objectTable;
-    IndirectCommandsLayoutNVX indirectCommandsLayout;
-    uint32_t maxSequencesCount;
-  };
-  static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceFeatures2
-  {
-    PhysicalDeviceFeatures2( PhysicalDeviceFeatures features_ = PhysicalDeviceFeatures() )
-      : features( features_ )
-    {
-    }
-
-    PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2 ) );
-    }
-
-    PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2 ) );
-      return *this;
-    }
-    PhysicalDeviceFeatures2& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures2& setFeatures( PhysicalDeviceFeatures features_ )
-    {
-      features = features_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceFeatures2 const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceFeatures2*>(this);
-    }
-
-    operator VkPhysicalDeviceFeatures2 &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceFeatures2*>(this);
-    }
-
-    bool operator==( PhysicalDeviceFeatures2 const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( features == rhs.features );
-    }
-
-    bool operator!=( PhysicalDeviceFeatures2 const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceFeatures2;
-
-  public:
-    void* pNext = nullptr;
-    PhysicalDeviceFeatures features;
-  };
-  static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "struct and wrapper have different size!" );
-
-  using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
-
-  struct PhysicalDevicePushDescriptorPropertiesKHR
-  {
-    PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 )
-      : maxPushDescriptors( maxPushDescriptors_ )
-    {
-    }
-
-    PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) );
-    }
-
-    PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) );
-      return *this;
-    }
-    PhysicalDevicePushDescriptorPropertiesKHR& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDevicePushDescriptorPropertiesKHR& setMaxPushDescriptors( uint32_t maxPushDescriptors_ )
-    {
-      maxPushDescriptors = maxPushDescriptors_;
-      return *this;
-    }
-
-    operator VkPhysicalDevicePushDescriptorPropertiesKHR const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(this);
-    }
-
-    operator VkPhysicalDevicePushDescriptorPropertiesKHR &()
-    {
-      return *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(this);
-    }
-
-    bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxPushDescriptors == rhs.maxPushDescriptors );
-    }
-
-    bool operator!=( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxPushDescriptors;
-  };
-  static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" );
-
-  struct PresentRegionsKHR
-  {
-    PresentRegionsKHR( uint32_t swapchainCount_ = 0,
-                       const PresentRegionKHR* pRegions_ = nullptr )
-      : swapchainCount( swapchainCount_ )
-      , pRegions( pRegions_ )
-    {
-    }
-
-    PresentRegionsKHR( VkPresentRegionsKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentRegionsKHR ) );
-    }
-
-    PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentRegionsKHR ) );
-      return *this;
-    }
-    PresentRegionsKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PresentRegionsKHR& setSwapchainCount( uint32_t swapchainCount_ )
-    {
-      swapchainCount = swapchainCount_;
-      return *this;
-    }
-
-    PresentRegionsKHR& setPRegions( const PresentRegionKHR* pRegions_ )
-    {
-      pRegions = pRegions_;
-      return *this;
-    }
-
-    operator VkPresentRegionsKHR const&() const
-    {
-      return *reinterpret_cast<const VkPresentRegionsKHR*>(this);
-    }
-
-    operator VkPresentRegionsKHR &()
-    {
-      return *reinterpret_cast<VkPresentRegionsKHR*>(this);
-    }
-
-    bool operator==( PresentRegionsKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( swapchainCount == rhs.swapchainCount )
-          && ( pRegions == rhs.pRegions );
-    }
-
-    bool operator!=( PresentRegionsKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePresentRegionsKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t swapchainCount;
-    const PresentRegionKHR* pRegions;
-  };
-  static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceVariablePointerFeatures
-  {
-    PhysicalDeviceVariablePointerFeatures( Bool32 variablePointersStorageBuffer_ = 0,
-                                           Bool32 variablePointers_ = 0 )
-      : variablePointersStorageBuffer( variablePointersStorageBuffer_ )
-      , variablePointers( variablePointers_ )
-    {
-    }
-
-    PhysicalDeviceVariablePointerFeatures( VkPhysicalDeviceVariablePointerFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeatures ) );
-    }
-
-    PhysicalDeviceVariablePointerFeatures& operator=( VkPhysicalDeviceVariablePointerFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeatures ) );
-      return *this;
-    }
-    PhysicalDeviceVariablePointerFeatures& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceVariablePointerFeatures& setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ )
-    {
-      variablePointersStorageBuffer = variablePointersStorageBuffer_;
-      return *this;
-    }
-
-    PhysicalDeviceVariablePointerFeatures& setVariablePointers( Bool32 variablePointers_ )
-    {
-      variablePointers = variablePointers_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceVariablePointerFeatures const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceVariablePointerFeatures*>(this);
-    }
-
-    operator VkPhysicalDeviceVariablePointerFeatures &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceVariablePointerFeatures*>(this);
-    }
-
-    bool operator==( PhysicalDeviceVariablePointerFeatures const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer )
-          && ( variablePointers == rhs.variablePointers );
-    }
-
-    bool operator!=( PhysicalDeviceVariablePointerFeatures const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceVariablePointerFeatures;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 variablePointersStorageBuffer;
-    Bool32 variablePointers;
-  };
-  static_assert( sizeof( PhysicalDeviceVariablePointerFeatures ) == sizeof( VkPhysicalDeviceVariablePointerFeatures ), "struct and wrapper have different size!" );
-
-  using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointerFeatures;
-
-  struct PhysicalDeviceIDProperties
-  {
-    operator VkPhysicalDeviceIDProperties const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceIDProperties*>(this);
-    }
-
-    operator VkPhysicalDeviceIDProperties &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceIDProperties*>(this);
-    }
-
-    bool operator==( PhysicalDeviceIDProperties const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memcmp( deviceUUID, rhs.deviceUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
-          && ( memcmp( driverUUID, rhs.driverUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
-          && ( memcmp( deviceLUID, rhs.deviceLUID, VK_LUID_SIZE * sizeof( uint8_t ) ) == 0 )
-          && ( deviceNodeMask == rhs.deviceNodeMask )
-          && ( deviceLUIDValid == rhs.deviceLUIDValid );
-    }
-
-    bool operator!=( PhysicalDeviceIDProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceIdProperties;
-
-  public:
-    void* pNext = nullptr;
-    uint8_t deviceUUID[VK_UUID_SIZE];
-    uint8_t driverUUID[VK_UUID_SIZE];
-    uint8_t deviceLUID[VK_LUID_SIZE];
-    uint32_t deviceNodeMask;
-    Bool32 deviceLUIDValid;
-  };
-  static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "struct and wrapper have different size!" );
-
-  using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ExportMemoryWin32HandleInfoKHR
-  {
-    ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
-                                    DWORD dwAccess_ = 0,
-                                    LPCWSTR name_ = 0 )
-      : pAttributes( pAttributes_ )
-      , dwAccess( dwAccess_ )
-      , name( name_ )
-    {
-    }
-
-    ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) );
-    }
-
-    ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) );
-      return *this;
-    }
-    ExportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportMemoryWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
-    {
-      pAttributes = pAttributes_;
-      return *this;
-    }
-
-    ExportMemoryWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ )
-    {
-      dwAccess = dwAccess_;
-      return *this;
-    }
-
-    ExportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ )
-    {
-      name = name_;
-      return *this;
-    }
-
-    operator VkExportMemoryWin32HandleInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(this);
-    }
-
-    operator VkExportMemoryWin32HandleInfoKHR &()
-    {
-      return *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( ExportMemoryWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pAttributes == rhs.pAttributes )
-          && ( dwAccess == rhs.dwAccess )
-          && ( name == rhs.name );
-    }
-
-    bool operator!=( ExportMemoryWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    const SECURITY_ATTRIBUTES* pAttributes;
-    DWORD dwAccess;
-    LPCWSTR name;
-  };
-  static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct MemoryWin32HandlePropertiesKHR
-  {
-    operator VkMemoryWin32HandlePropertiesKHR const&() const
-    {
-      return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>(this);
-    }
-
-    operator VkMemoryWin32HandlePropertiesKHR &()
-    {
-      return *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>(this);
-    }
-
-    bool operator==( MemoryWin32HandlePropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memoryTypeBits == rhs.memoryTypeBits );
-    }
-
-    bool operator!=( MemoryWin32HandlePropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t memoryTypeBits;
-  };
-  static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct MemoryFdPropertiesKHR
-  {
-    operator VkMemoryFdPropertiesKHR const&() const
-    {
-      return *reinterpret_cast<const VkMemoryFdPropertiesKHR*>(this);
-    }
-
-    operator VkMemoryFdPropertiesKHR &()
-    {
-      return *reinterpret_cast<VkMemoryFdPropertiesKHR*>(this);
-    }
-
-    bool operator==( MemoryFdPropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memoryTypeBits == rhs.memoryTypeBits );
-    }
-
-    bool operator!=( MemoryFdPropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryFdPropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t memoryTypeBits;
-  };
-  static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  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 )
-      : acquireCount( acquireCount_ )
-      , pAcquireSyncs( pAcquireSyncs_ )
-      , pAcquireKeys( pAcquireKeys_ )
-      , pAcquireTimeouts( pAcquireTimeouts_ )
-      , releaseCount( releaseCount_ )
-      , pReleaseSyncs( pReleaseSyncs_ )
-      , pReleaseKeys( pReleaseKeys_ )
-    {
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) );
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) );
-      return *this;
-    }
-    Win32KeyedMutexAcquireReleaseInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setAcquireCount( uint32_t acquireCount_ )
-    {
-      acquireCount = acquireCount_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
-    {
-      pAcquireSyncs = pAcquireSyncs_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireKeys( const uint64_t* pAcquireKeys_ )
-    {
-      pAcquireKeys = pAcquireKeys_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireTimeouts( const uint32_t* pAcquireTimeouts_ )
-    {
-      pAcquireTimeouts = pAcquireTimeouts_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setReleaseCount( uint32_t releaseCount_ )
-    {
-      releaseCount = releaseCount_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
-    {
-      pReleaseSyncs = pReleaseSyncs_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseKeys( const uint64_t* pReleaseKeys_ )
-    {
-      pReleaseKeys = pReleaseKeys_;
-      return *this;
-    }
-
-    operator VkWin32KeyedMutexAcquireReleaseInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this);
-    }
-
-    operator VkWin32KeyedMutexAcquireReleaseInfoKHR &()
-    {
-      return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this);
-    }
-
-    bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( acquireCount == rhs.acquireCount )
-          && ( pAcquireSyncs == rhs.pAcquireSyncs )
-          && ( pAcquireKeys == rhs.pAcquireKeys )
-          && ( pAcquireTimeouts == rhs.pAcquireTimeouts )
-          && ( releaseCount == rhs.releaseCount )
-          && ( pReleaseSyncs == rhs.pReleaseSyncs )
-          && ( pReleaseKeys == rhs.pReleaseKeys );
-    }
-
-    bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t acquireCount;
-    const DeviceMemory* pAcquireSyncs;
-    const uint64_t* pAcquireKeys;
-    const uint32_t* pAcquireTimeouts;
-    uint32_t releaseCount;
-    const DeviceMemory* pReleaseSyncs;
-    const uint64_t* pReleaseKeys;
-  };
-  static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ExportSemaphoreWin32HandleInfoKHR
-  {
-    ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
-                                       DWORD dwAccess_ = 0,
-                                       LPCWSTR name_ = 0 )
-      : pAttributes( pAttributes_ )
-      , dwAccess( dwAccess_ )
-      , name( name_ )
-    {
-    }
-
-    ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) );
-    }
-
-    ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) );
-      return *this;
-    }
-    ExportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportSemaphoreWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
-    {
-      pAttributes = pAttributes_;
-      return *this;
-    }
-
-    ExportSemaphoreWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ )
-    {
-      dwAccess = dwAccess_;
-      return *this;
-    }
-
-    ExportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ )
-    {
-      name = name_;
-      return *this;
-    }
-
-    operator VkExportSemaphoreWin32HandleInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(this);
-    }
-
-    operator VkExportSemaphoreWin32HandleInfoKHR &()
-    {
-      return *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pAttributes == rhs.pAttributes )
-          && ( dwAccess == rhs.dwAccess )
-          && ( name == rhs.name );
-    }
-
-    bool operator!=( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    const SECURITY_ATTRIBUTES* pAttributes;
-    DWORD dwAccess;
-    LPCWSTR name;
-  };
-  static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct D3D12FenceSubmitInfoKHR
-  {
-    D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0,
-                             const uint64_t* pWaitSemaphoreValues_ = nullptr,
-                             uint32_t signalSemaphoreValuesCount_ = 0,
-                             const uint64_t* pSignalSemaphoreValues_ = nullptr )
-      : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
-      , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
-      , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ )
-      , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
-    {
-    }
-
-    D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) );
-    }
-
-    D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) );
-      return *this;
-    }
-    D3D12FenceSubmitInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    D3D12FenceSubmitInfoKHR& setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ )
-    {
-      waitSemaphoreValuesCount = waitSemaphoreValuesCount_;
-      return *this;
-    }
-
-    D3D12FenceSubmitInfoKHR& setPWaitSemaphoreValues( const uint64_t* pWaitSemaphoreValues_ )
-    {
-      pWaitSemaphoreValues = pWaitSemaphoreValues_;
-      return *this;
-    }
-
-    D3D12FenceSubmitInfoKHR& setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ )
-    {
-      signalSemaphoreValuesCount = signalSemaphoreValuesCount_;
-      return *this;
-    }
-
-    D3D12FenceSubmitInfoKHR& setPSignalSemaphoreValues( const uint64_t* pSignalSemaphoreValues_ )
-    {
-      pSignalSemaphoreValues = pSignalSemaphoreValues_;
-      return *this;
-    }
-
-    operator VkD3D12FenceSubmitInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(this);
-    }
-
-    operator VkD3D12FenceSubmitInfoKHR &()
-    {
-      return *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(this);
-    }
-
-    bool operator==( D3D12FenceSubmitInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount )
-          && ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues )
-          && ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount )
-          && ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues );
-    }
-
-    bool operator!=( D3D12FenceSubmitInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreValuesCount;
-    const uint64_t* pWaitSemaphoreValues;
-    uint32_t signalSemaphoreValuesCount;
-    const uint64_t* pSignalSemaphoreValues;
-  };
-  static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ExportFenceWin32HandleInfoKHR
-  {
-    ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
-                                   DWORD dwAccess_ = 0,
-                                   LPCWSTR name_ = 0 )
-      : pAttributes( pAttributes_ )
-      , dwAccess( dwAccess_ )
-      , name( name_ )
-    {
-    }
-
-    ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) );
-    }
-
-    ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) );
-      return *this;
-    }
-    ExportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportFenceWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
-    {
-      pAttributes = pAttributes_;
-      return *this;
-    }
-
-    ExportFenceWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ )
-    {
-      dwAccess = dwAccess_;
-      return *this;
-    }
-
-    ExportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ )
-    {
-      name = name_;
-      return *this;
-    }
-
-    operator VkExportFenceWin32HandleInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(this);
-    }
-
-    operator VkExportFenceWin32HandleInfoKHR &()
-    {
-      return *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( ExportFenceWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pAttributes == rhs.pAttributes )
-          && ( dwAccess == rhs.dwAccess )
-          && ( name == rhs.name );
-    }
-
-    bool operator!=( ExportFenceWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    const SECURITY_ATTRIBUTES* pAttributes;
-    DWORD dwAccess;
-    LPCWSTR name;
-  };
-  static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct PhysicalDeviceMultiviewFeatures
-  {
-    PhysicalDeviceMultiviewFeatures( Bool32 multiview_ = 0,
-                                     Bool32 multiviewGeometryShader_ = 0,
-                                     Bool32 multiviewTessellationShader_ = 0 )
-      : multiview( multiview_ )
-      , multiviewGeometryShader( multiviewGeometryShader_ )
-      , multiviewTessellationShader( multiviewTessellationShader_ )
-    {
-    }
-
-    PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeatures ) );
-    }
-
-    PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeatures ) );
-      return *this;
-    }
-    PhysicalDeviceMultiviewFeatures& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceMultiviewFeatures& setMultiview( Bool32 multiview_ )
-    {
-      multiview = multiview_;
-      return *this;
-    }
-
-    PhysicalDeviceMultiviewFeatures& setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ )
-    {
-      multiviewGeometryShader = multiviewGeometryShader_;
-      return *this;
-    }
-
-    PhysicalDeviceMultiviewFeatures& setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ )
-    {
-      multiviewTessellationShader = multiviewTessellationShader_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceMultiviewFeatures const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(this);
-    }
-
-    operator VkPhysicalDeviceMultiviewFeatures &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(this);
-    }
-
-    bool operator==( PhysicalDeviceMultiviewFeatures const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( multiview == rhs.multiview )
-          && ( multiviewGeometryShader == rhs.multiviewGeometryShader )
-          && ( multiviewTessellationShader == rhs.multiviewTessellationShader );
-    }
-
-    bool operator!=( PhysicalDeviceMultiviewFeatures const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 multiview;
-    Bool32 multiviewGeometryShader;
-    Bool32 multiviewTessellationShader;
-  };
-  static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "struct and wrapper have different size!" );
-
-  using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
-
-  struct PhysicalDeviceMultiviewProperties
-  {
-    operator VkPhysicalDeviceMultiviewProperties const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(this);
-    }
-
-    operator VkPhysicalDeviceMultiviewProperties &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(this);
-    }
-
-    bool operator==( PhysicalDeviceMultiviewProperties const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxMultiviewViewCount == rhs.maxMultiviewViewCount )
-          && ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex );
-    }
-
-    bool operator!=( PhysicalDeviceMultiviewProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxMultiviewViewCount;
-    uint32_t maxMultiviewInstanceIndex;
-  };
-  static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "struct and wrapper have different size!" );
-
-  using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
-
-  struct RenderPassMultiviewCreateInfo
-  {
-    RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0,
-                                   const uint32_t* pViewMasks_ = nullptr,
-                                   uint32_t dependencyCount_ = 0,
-                                   const int32_t* pViewOffsets_ = nullptr,
-                                   uint32_t correlationMaskCount_ = 0,
-                                   const uint32_t* pCorrelationMasks_ = nullptr )
-      : subpassCount( subpassCount_ )
-      , pViewMasks( pViewMasks_ )
-      , dependencyCount( dependencyCount_ )
-      , pViewOffsets( pViewOffsets_ )
-      , correlationMaskCount( correlationMaskCount_ )
-      , pCorrelationMasks( pCorrelationMasks_ )
-    {
-    }
-
-    RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfo ) );
-    }
-
-    RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfo ) );
-      return *this;
-    }
-    RenderPassMultiviewCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    RenderPassMultiviewCreateInfo& setSubpassCount( uint32_t subpassCount_ )
-    {
-      subpassCount = subpassCount_;
-      return *this;
-    }
-
-    RenderPassMultiviewCreateInfo& setPViewMasks( const uint32_t* pViewMasks_ )
-    {
-      pViewMasks = pViewMasks_;
-      return *this;
-    }
-
-    RenderPassMultiviewCreateInfo& setDependencyCount( uint32_t dependencyCount_ )
-    {
-      dependencyCount = dependencyCount_;
-      return *this;
-    }
-
-    RenderPassMultiviewCreateInfo& setPViewOffsets( const int32_t* pViewOffsets_ )
-    {
-      pViewOffsets = pViewOffsets_;
-      return *this;
-    }
-
-    RenderPassMultiviewCreateInfo& setCorrelationMaskCount( uint32_t correlationMaskCount_ )
-    {
-      correlationMaskCount = correlationMaskCount_;
-      return *this;
-    }
-
-    RenderPassMultiviewCreateInfo& setPCorrelationMasks( const uint32_t* pCorrelationMasks_ )
-    {
-      pCorrelationMasks = pCorrelationMasks_;
-      return *this;
-    }
-
-    operator VkRenderPassMultiviewCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(this);
-    }
-
-    operator VkRenderPassMultiviewCreateInfo &()
-    {
-      return *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(this);
-    }
-
-    bool operator==( RenderPassMultiviewCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( subpassCount == rhs.subpassCount )
-          && ( pViewMasks == rhs.pViewMasks )
-          && ( dependencyCount == rhs.dependencyCount )
-          && ( pViewOffsets == rhs.pViewOffsets )
-          && ( correlationMaskCount == rhs.correlationMaskCount )
-          && ( pCorrelationMasks == rhs.pCorrelationMasks );
-    }
-
-    bool operator!=( RenderPassMultiviewCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eRenderPassMultiviewCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t subpassCount;
-    const uint32_t* pViewMasks;
-    uint32_t dependencyCount;
-    const int32_t* pViewOffsets;
-    uint32_t correlationMaskCount;
-    const uint32_t* pCorrelationMasks;
-  };
-  static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "struct and wrapper have different size!" );
-
-  using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
-
-  struct BindBufferMemoryInfo
-  {
-    BindBufferMemoryInfo( Buffer buffer_ = Buffer(),
-                          DeviceMemory memory_ = DeviceMemory(),
-                          DeviceSize memoryOffset_ = 0 )
-      : buffer( buffer_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
-    {
-    }
-
-    BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindBufferMemoryInfo ) );
-    }
-
-    BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindBufferMemoryInfo ) );
-      return *this;
-    }
-    BindBufferMemoryInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindBufferMemoryInfo& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    BindBufferMemoryInfo& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    BindBufferMemoryInfo& setMemoryOffset( DeviceSize memoryOffset_ )
-    {
-      memoryOffset = memoryOffset_;
-      return *this;
-    }
-
-    operator VkBindBufferMemoryInfo const&() const
-    {
-      return *reinterpret_cast<const VkBindBufferMemoryInfo*>(this);
-    }
-
-    operator VkBindBufferMemoryInfo &()
-    {
-      return *reinterpret_cast<VkBindBufferMemoryInfo*>(this);
-    }
-
-    bool operator==( BindBufferMemoryInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( buffer == rhs.buffer )
-          && ( memory == rhs.memory )
-          && ( memoryOffset == rhs.memoryOffset );
-    }
-
-    bool operator!=( BindBufferMemoryInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindBufferMemoryInfo;
-
-  public:
-    const void* pNext = nullptr;
-    Buffer buffer;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
-  };
-  static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "struct and wrapper have different size!" );
-
-  using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
-
-  struct BindBufferMemoryDeviceGroupInfo
-  {
-    BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
-                                     const uint32_t* pDeviceIndices_ = nullptr )
-      : deviceIndexCount( deviceIndexCount_ )
-      , pDeviceIndices( pDeviceIndices_ )
-    {
-    }
-
-    BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfo ) );
-    }
-
-    BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfo ) );
-      return *this;
-    }
-    BindBufferMemoryDeviceGroupInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindBufferMemoryDeviceGroupInfo& setDeviceIndexCount( uint32_t deviceIndexCount_ )
-    {
-      deviceIndexCount = deviceIndexCount_;
-      return *this;
-    }
-
-    BindBufferMemoryDeviceGroupInfo& setPDeviceIndices( const uint32_t* pDeviceIndices_ )
-    {
-      pDeviceIndices = pDeviceIndices_;
-      return *this;
-    }
-
-    operator VkBindBufferMemoryDeviceGroupInfo const&() const
-    {
-      return *reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(this);
-    }
-
-    operator VkBindBufferMemoryDeviceGroupInfo &()
-    {
-      return *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(this);
-    }
-
-    bool operator==( BindBufferMemoryDeviceGroupInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( deviceIndexCount == rhs.deviceIndexCount )
-          && ( pDeviceIndices == rhs.pDeviceIndices );
-    }
-
-    bool operator!=( BindBufferMemoryDeviceGroupInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t deviceIndexCount;
-    const uint32_t* pDeviceIndices;
-  };
-  static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "struct and wrapper have different size!" );
-
-  using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
-
-  struct BindImageMemoryInfo
-  {
-    BindImageMemoryInfo( Image image_ = Image(),
-                         DeviceMemory memory_ = DeviceMemory(),
-                         DeviceSize memoryOffset_ = 0 )
-      : image( image_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
-    {
-    }
-
-    BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImageMemoryInfo ) );
-    }
-
-    BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImageMemoryInfo ) );
-      return *this;
-    }
-    BindImageMemoryInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindImageMemoryInfo& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    BindImageMemoryInfo& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    BindImageMemoryInfo& setMemoryOffset( DeviceSize memoryOffset_ )
-    {
-      memoryOffset = memoryOffset_;
-      return *this;
-    }
-
-    operator VkBindImageMemoryInfo const&() const
-    {
-      return *reinterpret_cast<const VkBindImageMemoryInfo*>(this);
-    }
-
-    operator VkBindImageMemoryInfo &()
-    {
-      return *reinterpret_cast<VkBindImageMemoryInfo*>(this);
-    }
-
-    bool operator==( BindImageMemoryInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( image == rhs.image )
-          && ( memory == rhs.memory )
-          && ( memoryOffset == rhs.memoryOffset );
-    }
-
-    bool operator!=( BindImageMemoryInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindImageMemoryInfo;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
-  };
-  static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "struct and wrapper have different size!" );
-
-  using BindImageMemoryInfoKHR = BindImageMemoryInfo;
-
-  struct BindImageMemoryDeviceGroupInfo
-  {
-    BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
-                                    const uint32_t* pDeviceIndices_ = nullptr,
-                                    uint32_t splitInstanceBindRegionCount_ = 0,
-                                    const Rect2D* pSplitInstanceBindRegions_ = nullptr )
-      : deviceIndexCount( deviceIndexCount_ )
-      , pDeviceIndices( pDeviceIndices_ )
-      , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ )
-      , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ )
-    {
-    }
-
-    BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfo ) );
-    }
-
-    BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfo ) );
-      return *this;
-    }
-    BindImageMemoryDeviceGroupInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindImageMemoryDeviceGroupInfo& setDeviceIndexCount( uint32_t deviceIndexCount_ )
-    {
-      deviceIndexCount = deviceIndexCount_;
-      return *this;
-    }
-
-    BindImageMemoryDeviceGroupInfo& setPDeviceIndices( const uint32_t* pDeviceIndices_ )
-    {
-      pDeviceIndices = pDeviceIndices_;
-      return *this;
-    }
-
-    BindImageMemoryDeviceGroupInfo& setSplitInstanceBindRegionCount( uint32_t splitInstanceBindRegionCount_ )
-    {
-      splitInstanceBindRegionCount = splitInstanceBindRegionCount_;
-      return *this;
-    }
-
-    BindImageMemoryDeviceGroupInfo& setPSplitInstanceBindRegions( const Rect2D* pSplitInstanceBindRegions_ )
-    {
-      pSplitInstanceBindRegions = pSplitInstanceBindRegions_;
-      return *this;
-    }
-
-    operator VkBindImageMemoryDeviceGroupInfo const&() const
-    {
-      return *reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(this);
-    }
-
-    operator VkBindImageMemoryDeviceGroupInfo &()
-    {
-      return *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(this);
-    }
-
-    bool operator==( BindImageMemoryDeviceGroupInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( deviceIndexCount == rhs.deviceIndexCount )
-          && ( pDeviceIndices == rhs.pDeviceIndices )
-          && ( splitInstanceBindRegionCount == rhs.splitInstanceBindRegionCount )
-          && ( pSplitInstanceBindRegions == rhs.pSplitInstanceBindRegions );
-    }
-
-    bool operator!=( BindImageMemoryDeviceGroupInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t deviceIndexCount;
-    const uint32_t* pDeviceIndices;
-    uint32_t splitInstanceBindRegionCount;
-    const Rect2D* pSplitInstanceBindRegions;
-  };
-  static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "struct and wrapper have different size!" );
-
-  using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
-
-  struct DeviceGroupRenderPassBeginInfo
-  {
-    DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0,
-                                    uint32_t deviceRenderAreaCount_ = 0,
-                                    const Rect2D* pDeviceRenderAreas_ = nullptr )
-      : deviceMask( deviceMask_ )
-      , deviceRenderAreaCount( deviceRenderAreaCount_ )
-      , pDeviceRenderAreas( pDeviceRenderAreas_ )
-    {
-    }
-
-    DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfo ) );
-    }
-
-    DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfo ) );
-      return *this;
-    }
-    DeviceGroupRenderPassBeginInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupRenderPassBeginInfo& setDeviceMask( uint32_t deviceMask_ )
-    {
-      deviceMask = deviceMask_;
-      return *this;
-    }
-
-    DeviceGroupRenderPassBeginInfo& setDeviceRenderAreaCount( uint32_t deviceRenderAreaCount_ )
-    {
-      deviceRenderAreaCount = deviceRenderAreaCount_;
-      return *this;
-    }
-
-    DeviceGroupRenderPassBeginInfo& setPDeviceRenderAreas( const Rect2D* pDeviceRenderAreas_ )
-    {
-      pDeviceRenderAreas = pDeviceRenderAreas_;
-      return *this;
-    }
-
-    operator VkDeviceGroupRenderPassBeginInfo const&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(this);
-    }
-
-    operator VkDeviceGroupRenderPassBeginInfo &()
-    {
-      return *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(this);
-    }
-
-    bool operator==( DeviceGroupRenderPassBeginInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( deviceMask == rhs.deviceMask )
-          && ( deviceRenderAreaCount == rhs.deviceRenderAreaCount )
-          && ( pDeviceRenderAreas == rhs.pDeviceRenderAreas );
-    }
-
-    bool operator!=( DeviceGroupRenderPassBeginInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t deviceMask;
-    uint32_t deviceRenderAreaCount;
-    const Rect2D* pDeviceRenderAreas;
-  };
-  static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "struct and wrapper have different size!" );
-
-  using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
-
-  struct DeviceGroupCommandBufferBeginInfo
-  {
-    DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 )
-      : deviceMask( deviceMask_ )
-    {
-    }
-
-    DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfo ) );
-    }
-
-    DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfo ) );
-      return *this;
-    }
-    DeviceGroupCommandBufferBeginInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupCommandBufferBeginInfo& setDeviceMask( uint32_t deviceMask_ )
-    {
-      deviceMask = deviceMask_;
-      return *this;
-    }
-
-    operator VkDeviceGroupCommandBufferBeginInfo const&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(this);
-    }
-
-    operator VkDeviceGroupCommandBufferBeginInfo &()
-    {
-      return *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(this);
-    }
-
-    bool operator==( DeviceGroupCommandBufferBeginInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( deviceMask == rhs.deviceMask );
-    }
-
-    bool operator!=( DeviceGroupCommandBufferBeginInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t deviceMask;
-  };
-  static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "struct and wrapper have different size!" );
-
-  using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
-
-  struct DeviceGroupSubmitInfo
-  {
-    DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0,
-                           const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr,
-                           uint32_t commandBufferCount_ = 0,
-                           const uint32_t* pCommandBufferDeviceMasks_ = nullptr,
-                           uint32_t signalSemaphoreCount_ = 0,
-                           const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr )
-      : waitSemaphoreCount( waitSemaphoreCount_ )
-      , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ )
-      , commandBufferCount( commandBufferCount_ )
-      , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ )
-      , signalSemaphoreCount( signalSemaphoreCount_ )
-      , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ )
-    {
-    }
-
-    DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfo ) );
-    }
-
-    DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfo ) );
-      return *this;
-    }
-    DeviceGroupSubmitInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupSubmitInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
-    {
-      waitSemaphoreCount = waitSemaphoreCount_;
-      return *this;
-    }
-
-    DeviceGroupSubmitInfo& setPWaitSemaphoreDeviceIndices( const uint32_t* pWaitSemaphoreDeviceIndices_ )
-    {
-      pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices_;
-      return *this;
-    }
-
-    DeviceGroupSubmitInfo& setCommandBufferCount( uint32_t commandBufferCount_ )
-    {
-      commandBufferCount = commandBufferCount_;
-      return *this;
-    }
-
-    DeviceGroupSubmitInfo& setPCommandBufferDeviceMasks( const uint32_t* pCommandBufferDeviceMasks_ )
-    {
-      pCommandBufferDeviceMasks = pCommandBufferDeviceMasks_;
-      return *this;
-    }
-
-    DeviceGroupSubmitInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
-    {
-      signalSemaphoreCount = signalSemaphoreCount_;
-      return *this;
-    }
-
-    DeviceGroupSubmitInfo& setPSignalSemaphoreDeviceIndices( const uint32_t* pSignalSemaphoreDeviceIndices_ )
-    {
-      pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices_;
-      return *this;
-    }
-
-    operator VkDeviceGroupSubmitInfo const&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupSubmitInfo*>(this);
-    }
-
-    operator VkDeviceGroupSubmitInfo &()
-    {
-      return *reinterpret_cast<VkDeviceGroupSubmitInfo*>(this);
-    }
-
-    bool operator==( DeviceGroupSubmitInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
-          && ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices )
-          && ( commandBufferCount == rhs.commandBufferCount )
-          && ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks )
-          && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
-          && ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices );
-    }
-
-    bool operator!=( DeviceGroupSubmitInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupSubmitInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreCount;
-    const uint32_t* pWaitSemaphoreDeviceIndices;
-    uint32_t commandBufferCount;
-    const uint32_t* pCommandBufferDeviceMasks;
-    uint32_t signalSemaphoreCount;
-    const uint32_t* pSignalSemaphoreDeviceIndices;
-  };
-  static_assert( sizeof( DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), "struct and wrapper have different size!" );
-
-  using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
-
-  struct DeviceGroupBindSparseInfo
-  {
-    DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0,
-                               uint32_t memoryDeviceIndex_ = 0 )
-      : resourceDeviceIndex( resourceDeviceIndex_ )
-      , memoryDeviceIndex( memoryDeviceIndex_ )
-    {
-    }
-
-    DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfo ) );
-    }
-
-    DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfo ) );
-      return *this;
-    }
-    DeviceGroupBindSparseInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupBindSparseInfo& setResourceDeviceIndex( uint32_t resourceDeviceIndex_ )
-    {
-      resourceDeviceIndex = resourceDeviceIndex_;
-      return *this;
-    }
-
-    DeviceGroupBindSparseInfo& setMemoryDeviceIndex( uint32_t memoryDeviceIndex_ )
-    {
-      memoryDeviceIndex = memoryDeviceIndex_;
-      return *this;
-    }
-
-    operator VkDeviceGroupBindSparseInfo const&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(this);
-    }
-
-    operator VkDeviceGroupBindSparseInfo &()
-    {
-      return *reinterpret_cast<VkDeviceGroupBindSparseInfo*>(this);
-    }
-
-    bool operator==( DeviceGroupBindSparseInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( resourceDeviceIndex == rhs.resourceDeviceIndex )
-          && ( memoryDeviceIndex == rhs.memoryDeviceIndex );
-    }
-
-    bool operator!=( DeviceGroupBindSparseInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupBindSparseInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t resourceDeviceIndex;
-    uint32_t memoryDeviceIndex;
-  };
-  static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "struct and wrapper have different size!" );
-
-  using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
-
-  struct ImageSwapchainCreateInfoKHR
-  {
-    ImageSwapchainCreateInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR() )
-      : swapchain( swapchain_ )
-    {
-    }
-
-    ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHR ) );
-    }
-
-    ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHR ) );
-      return *this;
-    }
-    ImageSwapchainCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageSwapchainCreateInfoKHR& setSwapchain( SwapchainKHR swapchain_ )
-    {
-      swapchain = swapchain_;
-      return *this;
-    }
-
-    operator VkImageSwapchainCreateInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(this);
-    }
-
-    operator VkImageSwapchainCreateInfoKHR &()
-    {
-      return *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(this);
-    }
-
-    bool operator==( ImageSwapchainCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( swapchain == rhs.swapchain );
-    }
-
-    bool operator!=( ImageSwapchainCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageSwapchainCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    SwapchainKHR swapchain;
-  };
-  static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  struct BindImageMemorySwapchainInfoKHR
-  {
-    BindImageMemorySwapchainInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR(),
-                                     uint32_t imageIndex_ = 0 )
-      : swapchain( swapchain_ )
-      , imageIndex( imageIndex_ )
-    {
-    }
-
-    BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHR ) );
-    }
-
-    BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHR ) );
-      return *this;
-    }
-    BindImageMemorySwapchainInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindImageMemorySwapchainInfoKHR& setSwapchain( SwapchainKHR swapchain_ )
-    {
-      swapchain = swapchain_;
-      return *this;
-    }
-
-    BindImageMemorySwapchainInfoKHR& setImageIndex( uint32_t imageIndex_ )
-    {
-      imageIndex = imageIndex_;
-      return *this;
-    }
-
-    operator VkBindImageMemorySwapchainInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(this);
-    }
-
-    operator VkBindImageMemorySwapchainInfoKHR &()
-    {
-      return *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(this);
-    }
-
-    bool operator==( BindImageMemorySwapchainInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( swapchain == rhs.swapchain )
-          && ( imageIndex == rhs.imageIndex );
-    }
-
-    bool operator!=( BindImageMemorySwapchainInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    SwapchainKHR swapchain;
-    uint32_t imageIndex;
-  };
-  static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "struct and wrapper have different size!" );
-
-  struct AcquireNextImageInfoKHR
-  {
-    AcquireNextImageInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR(),
-                             uint64_t timeout_ = 0,
-                             Semaphore semaphore_ = Semaphore(),
-                             Fence fence_ = Fence(),
-                             uint32_t deviceMask_ = 0 )
-      : swapchain( swapchain_ )
-      , timeout( timeout_ )
-      , semaphore( semaphore_ )
-      , fence( fence_ )
-      , deviceMask( deviceMask_ )
-    {
-    }
-
-    AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHR ) );
-    }
-
-    AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHR ) );
-      return *this;
-    }
-    AcquireNextImageInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    AcquireNextImageInfoKHR& setSwapchain( SwapchainKHR swapchain_ )
-    {
-      swapchain = swapchain_;
-      return *this;
-    }
-
-    AcquireNextImageInfoKHR& setTimeout( uint64_t timeout_ )
-    {
-      timeout = timeout_;
-      return *this;
-    }
-
-    AcquireNextImageInfoKHR& setSemaphore( Semaphore semaphore_ )
-    {
-      semaphore = semaphore_;
-      return *this;
-    }
-
-    AcquireNextImageInfoKHR& setFence( Fence fence_ )
-    {
-      fence = fence_;
-      return *this;
-    }
-
-    AcquireNextImageInfoKHR& setDeviceMask( uint32_t deviceMask_ )
-    {
-      deviceMask = deviceMask_;
-      return *this;
-    }
-
-    operator VkAcquireNextImageInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkAcquireNextImageInfoKHR*>(this);
-    }
-
-    operator VkAcquireNextImageInfoKHR &()
-    {
-      return *reinterpret_cast<VkAcquireNextImageInfoKHR*>(this);
-    }
-
-    bool operator==( AcquireNextImageInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( swapchain == rhs.swapchain )
-          && ( timeout == rhs.timeout )
-          && ( semaphore == rhs.semaphore )
-          && ( fence == rhs.fence )
-          && ( deviceMask == rhs.deviceMask );
-    }
-
-    bool operator!=( AcquireNextImageInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eAcquireNextImageInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    SwapchainKHR swapchain;
-    uint64_t timeout;
-    Semaphore semaphore;
-    Fence fence;
-    uint32_t deviceMask;
-  };
-  static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "struct and wrapper have different size!" );
+  static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" );
 
   struct HdrMetadataEXT
   {
@@ -14887,8 +29800,7 @@ public:
       , minLuminance( minLuminance_ )
       , maxContentLightLevel( maxContentLightLevel_ )
       , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ )
-    {
-    }
+    {}
 
     HdrMetadataEXT( VkHdrMetadataEXT const & rhs )
     {
@@ -14900,55 +29812,56 @@ public:
       memcpy( this, &rhs, sizeof( HdrMetadataEXT ) );
       return *this;
     }
-    HdrMetadataEXT& setPNext( const void* pNext_ )
+
+    HdrMetadataEXT & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    HdrMetadataEXT& setDisplayPrimaryRed( XYColorEXT displayPrimaryRed_ )
+    HdrMetadataEXT & setDisplayPrimaryRed( XYColorEXT displayPrimaryRed_ )
     {
       displayPrimaryRed = displayPrimaryRed_;
       return *this;
     }
 
-    HdrMetadataEXT& setDisplayPrimaryGreen( XYColorEXT displayPrimaryGreen_ )
+    HdrMetadataEXT & setDisplayPrimaryGreen( XYColorEXT displayPrimaryGreen_ )
     {
       displayPrimaryGreen = displayPrimaryGreen_;
       return *this;
     }
 
-    HdrMetadataEXT& setDisplayPrimaryBlue( XYColorEXT displayPrimaryBlue_ )
+    HdrMetadataEXT & setDisplayPrimaryBlue( XYColorEXT displayPrimaryBlue_ )
     {
       displayPrimaryBlue = displayPrimaryBlue_;
       return *this;
     }
 
-    HdrMetadataEXT& setWhitePoint( XYColorEXT whitePoint_ )
+    HdrMetadataEXT & setWhitePoint( XYColorEXT whitePoint_ )
     {
       whitePoint = whitePoint_;
       return *this;
     }
 
-    HdrMetadataEXT& setMaxLuminance( float maxLuminance_ )
+    HdrMetadataEXT & setMaxLuminance( float maxLuminance_ )
     {
       maxLuminance = maxLuminance_;
       return *this;
     }
 
-    HdrMetadataEXT& setMinLuminance( float minLuminance_ )
+    HdrMetadataEXT & setMinLuminance( float minLuminance_ )
     {
       minLuminance = minLuminance_;
       return *this;
     }
 
-    HdrMetadataEXT& setMaxContentLightLevel( float maxContentLightLevel_ )
+    HdrMetadataEXT & setMaxContentLightLevel( float maxContentLightLevel_ )
     {
       maxContentLightLevel = maxContentLightLevel_;
       return *this;
     }
 
-    HdrMetadataEXT& setMaxFrameAverageLightLevel( float maxFrameAverageLightLevel_ )
+    HdrMetadataEXT & setMaxFrameAverageLightLevel( float maxFrameAverageLightLevel_ )
     {
       maxFrameAverageLightLevel = maxFrameAverageLightLevel_;
       return *this;
@@ -14956,12 +29869,12 @@ public:
 
     operator VkHdrMetadataEXT const&() const
     {
-      return *reinterpret_cast<const VkHdrMetadataEXT*>(this);
+      return *reinterpret_cast<const VkHdrMetadataEXT*>( this );
     }
 
     operator VkHdrMetadataEXT &()
     {
-      return *reinterpret_cast<VkHdrMetadataEXT*>(this);
+      return *reinterpret_cast<VkHdrMetadataEXT*>( this );
     }
 
     bool operator==( HdrMetadataEXT const& rhs ) const
@@ -14999,76 +29912,6 @@ public:
   };
   static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" );
 
-  struct PresentTimesInfoGOOGLE
-  {
-    PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0,
-                            const PresentTimeGOOGLE* pTimes_ = nullptr )
-      : swapchainCount( swapchainCount_ )
-      , pTimes( pTimes_ )
-    {
-    }
-
-    PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) );
-    }
-
-    PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) );
-      return *this;
-    }
-    PresentTimesInfoGOOGLE& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PresentTimesInfoGOOGLE& setSwapchainCount( uint32_t swapchainCount_ )
-    {
-      swapchainCount = swapchainCount_;
-      return *this;
-    }
-
-    PresentTimesInfoGOOGLE& setPTimes( const PresentTimeGOOGLE* pTimes_ )
-    {
-      pTimes = pTimes_;
-      return *this;
-    }
-
-    operator VkPresentTimesInfoGOOGLE const&() const
-    {
-      return *reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(this);
-    }
-
-    operator VkPresentTimesInfoGOOGLE &()
-    {
-      return *reinterpret_cast<VkPresentTimesInfoGOOGLE*>(this);
-    }
-
-    bool operator==( PresentTimesInfoGOOGLE const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( swapchainCount == rhs.swapchainCount )
-          && ( pTimes == rhs.pTimes );
-    }
-
-    bool operator!=( PresentTimesInfoGOOGLE const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePresentTimesInfoGOOGLE;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t swapchainCount;
-    const PresentTimeGOOGLE* pTimes;
-  };
-  static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "struct and wrapper have different size!" );
-
 #ifdef VK_USE_PLATFORM_IOS_MVK
   struct IOSSurfaceCreateInfoMVK
   {
@@ -15076,8 +29919,7 @@ public:
                              const void* pView_ = nullptr )
       : flags( flags_ )
       , pView( pView_ )
-    {
-    }
+    {}
 
     IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs )
     {
@@ -15089,19 +29931,20 @@ public:
       memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) );
       return *this;
     }
-    IOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ )
+
+    IOSSurfaceCreateInfoMVK & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    IOSSurfaceCreateInfoMVK& setFlags( IOSSurfaceCreateFlagsMVK flags_ )
+    IOSSurfaceCreateInfoMVK & setFlags( IOSSurfaceCreateFlagsMVK flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    IOSSurfaceCreateInfoMVK& setPView( const void* pView_ )
+    IOSSurfaceCreateInfoMVK & setPView( const void* pView_ )
     {
       pView = pView_;
       return *this;
@@ -15109,12 +29952,12 @@ public:
 
     operator VkIOSSurfaceCreateInfoMVK const&() const
     {
-      return *reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>(this);
+      return *reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( this );
     }
 
     operator VkIOSSurfaceCreateInfoMVK &()
     {
-      return *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>(this);
+      return *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>( this );
     }
 
     bool operator==( IOSSurfaceCreateInfoMVK const& rhs ) const
@@ -15141,6 +29984,2693 @@ public:
   static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
 #endif /*VK_USE_PLATFORM_IOS_MVK*/
 
+  struct ImageBlit
+  {
+    ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
+               std::array<Offset3D,2> const& srcOffsets_ = { { Offset3D() } },
+               ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
+               std::array<Offset3D,2> const& dstOffsets_ = { { Offset3D() } } )
+      : srcSubresource( srcSubresource_ )
+      , dstSubresource( dstSubresource_ )
+    {
+      memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
+      memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
+    }
+
+    ImageBlit( VkImageBlit const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageBlit ) );
+    }
+
+    ImageBlit& operator=( VkImageBlit const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageBlit ) );
+      return *this;
+    }
+
+    ImageBlit & setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+    {
+      srcSubresource = srcSubresource_;
+      return *this;
+    }
+
+    ImageBlit & setSrcOffsets( std::array<Offset3D,2> srcOffsets_ )
+    {
+      memcpy( srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
+      return *this;
+    }
+
+    ImageBlit & setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+    {
+      dstSubresource = dstSubresource_;
+      return *this;
+    }
+
+    ImageBlit & setDstOffsets( std::array<Offset3D,2> dstOffsets_ )
+    {
+      memcpy( dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
+      return *this;
+    }
+
+    operator VkImageBlit const&() const
+    {
+      return *reinterpret_cast<const VkImageBlit*>( this );
+    }
+
+    operator VkImageBlit &()
+    {
+      return *reinterpret_cast<VkImageBlit*>( this );
+    }
+
+    bool operator==( ImageBlit const& rhs ) const
+    {
+      return ( srcSubresource == rhs.srcSubresource )
+          && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 )
+          && ( dstSubresource == rhs.dstSubresource )
+          && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 );
+    }
+
+    bool operator!=( ImageBlit const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ImageSubresourceLayers srcSubresource;
+    Offset3D srcOffsets[2];
+    ImageSubresourceLayers dstSubresource;
+    Offset3D dstOffsets[2];
+  };
+  static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" );
+
+  struct ImageCopy
+  {
+    ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
+               Offset3D srcOffset_ = Offset3D(),
+               ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
+               Offset3D dstOffset_ = Offset3D(),
+               Extent3D extent_ = Extent3D() )
+      : srcSubresource( srcSubresource_ )
+      , srcOffset( srcOffset_ )
+      , dstSubresource( dstSubresource_ )
+      , dstOffset( dstOffset_ )
+      , extent( extent_ )
+    {}
+
+    ImageCopy( VkImageCopy const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageCopy ) );
+    }
+
+    ImageCopy& operator=( VkImageCopy const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageCopy ) );
+      return *this;
+    }
+
+    ImageCopy & setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+    {
+      srcSubresource = srcSubresource_;
+      return *this;
+    }
+
+    ImageCopy & setSrcOffset( Offset3D srcOffset_ )
+    {
+      srcOffset = srcOffset_;
+      return *this;
+    }
+
+    ImageCopy & setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+    {
+      dstSubresource = dstSubresource_;
+      return *this;
+    }
+
+    ImageCopy & setDstOffset( Offset3D dstOffset_ )
+    {
+      dstOffset = dstOffset_;
+      return *this;
+    }
+
+    ImageCopy & setExtent( Extent3D extent_ )
+    {
+      extent = extent_;
+      return *this;
+    }
+
+    operator VkImageCopy const&() const
+    {
+      return *reinterpret_cast<const VkImageCopy*>( this );
+    }
+
+    operator VkImageCopy &()
+    {
+      return *reinterpret_cast<VkImageCopy*>( this );
+    }
+
+    bool operator==( ImageCopy const& rhs ) const
+    {
+      return ( srcSubresource == rhs.srcSubresource )
+          && ( srcOffset == rhs.srcOffset )
+          && ( dstSubresource == rhs.dstSubresource )
+          && ( dstOffset == rhs.dstOffset )
+          && ( extent == rhs.extent );
+    }
+
+    bool operator!=( ImageCopy const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ImageSubresourceLayers srcSubresource;
+    Offset3D srcOffset;
+    ImageSubresourceLayers dstSubresource;
+    Offset3D dstOffset;
+    Extent3D extent;
+  };
+  static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" );
+
+  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 )
+      : flags( flags_ )
+      , imageType( imageType_ )
+      , format( format_ )
+      , extent( extent_ )
+      , mipLevels( mipLevels_ )
+      , arrayLayers( arrayLayers_ )
+      , samples( samples_ )
+      , tiling( tiling_ )
+      , usage( usage_ )
+      , sharingMode( sharingMode_ )
+      , queueFamilyIndexCount( queueFamilyIndexCount_ )
+      , pQueueFamilyIndices( pQueueFamilyIndices_ )
+      , initialLayout( initialLayout_ )
+    {}
+
+    ImageCreateInfo( VkImageCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
+    }
+
+    ImageCreateInfo& operator=( VkImageCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
+      return *this;
+    }
+
+    ImageCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImageCreateInfo & setFlags( ImageCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ImageCreateInfo & setImageType( ImageType imageType_ )
+    {
+      imageType = imageType_;
+      return *this;
+    }
+
+    ImageCreateInfo & setFormat( Format format_ )
+    {
+      format = format_;
+      return *this;
+    }
+
+    ImageCreateInfo & setExtent( Extent3D extent_ )
+    {
+      extent = extent_;
+      return *this;
+    }
+
+    ImageCreateInfo & setMipLevels( uint32_t mipLevels_ )
+    {
+      mipLevels = mipLevels_;
+      return *this;
+    }
+
+    ImageCreateInfo & setArrayLayers( uint32_t arrayLayers_ )
+    {
+      arrayLayers = arrayLayers_;
+      return *this;
+    }
+
+    ImageCreateInfo & setSamples( SampleCountFlagBits samples_ )
+    {
+      samples = samples_;
+      return *this;
+    }
+
+    ImageCreateInfo & setTiling( ImageTiling tiling_ )
+    {
+      tiling = tiling_;
+      return *this;
+    }
+
+    ImageCreateInfo & setUsage( ImageUsageFlags usage_ )
+    {
+      usage = usage_;
+      return *this;
+    }
+
+    ImageCreateInfo & setSharingMode( SharingMode sharingMode_ )
+    {
+      sharingMode = sharingMode_;
+      return *this;
+    }
+
+    ImageCreateInfo & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+    {
+      queueFamilyIndexCount = queueFamilyIndexCount_;
+      return *this;
+    }
+
+    ImageCreateInfo & setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
+    {
+      pQueueFamilyIndices = pQueueFamilyIndices_;
+      return *this;
+    }
+
+    ImageCreateInfo & setInitialLayout( ImageLayout initialLayout_ )
+    {
+      initialLayout = initialLayout_;
+      return *this;
+    }
+
+    operator VkImageCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkImageCreateInfo*>( this );
+    }
+
+    operator VkImageCreateInfo &()
+    {
+      return *reinterpret_cast<VkImageCreateInfo*>( this );
+    }
+
+    bool operator==( ImageCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( imageType == rhs.imageType )
+          && ( format == rhs.format )
+          && ( extent == rhs.extent )
+          && ( mipLevels == rhs.mipLevels )
+          && ( arrayLayers == rhs.arrayLayers )
+          && ( samples == rhs.samples )
+          && ( tiling == rhs.tiling )
+          && ( usage == rhs.usage )
+          && ( sharingMode == rhs.sharingMode )
+          && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
+          && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
+          && ( initialLayout == rhs.initialLayout );
+    }
+
+    bool operator!=( ImageCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    ImageCreateFlags flags;
+    ImageType imageType;
+    Format format;
+    Extent3D extent;
+    uint32_t mipLevels;
+    uint32_t arrayLayers;
+    SampleCountFlagBits samples;
+    ImageTiling tiling;
+    ImageUsageFlags usage;
+    SharingMode sharingMode;
+    uint32_t queueFamilyIndexCount;
+    const uint32_t* pQueueFamilyIndices;
+    ImageLayout initialLayout;
+  };
+  static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" );
+
+  struct SubresourceLayout
+  {
+    operator VkSubresourceLayout const&() const
+    {
+      return *reinterpret_cast<const VkSubresourceLayout*>( this );
+    }
+
+    operator VkSubresourceLayout &()
+    {
+      return *reinterpret_cast<VkSubresourceLayout*>( this );
+    }
+
+    bool operator==( SubresourceLayout const& rhs ) const
+    {
+      return ( offset == rhs.offset )
+          && ( size == rhs.size )
+          && ( rowPitch == rhs.rowPitch )
+          && ( arrayPitch == rhs.arrayPitch )
+          && ( depthPitch == rhs.depthPitch );
+    }
+
+    bool operator!=( SubresourceLayout const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    DeviceSize offset;
+    DeviceSize size;
+    DeviceSize rowPitch;
+    DeviceSize arrayPitch;
+    DeviceSize depthPitch;
+  };
+  static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" );
+
+  struct ImageDrmFormatModifierExplicitCreateInfoEXT
+  {
+    ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0,
+                                                 uint32_t drmFormatModifierPlaneCount_ = 0,
+                                                 const SubresourceLayout* pPlaneLayouts_ = nullptr )
+      : drmFormatModifier( drmFormatModifier_ )
+      , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ )
+      , pPlaneLayouts( pPlaneLayouts_ )
+    {}
+
+    ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) );
+    }
+
+    ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) );
+      return *this;
+    }
+
+    ImageDrmFormatModifierExplicitCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImageDrmFormatModifierExplicitCreateInfoEXT & setDrmFormatModifier( uint64_t drmFormatModifier_ )
+    {
+      drmFormatModifier = drmFormatModifier_;
+      return *this;
+    }
+
+    ImageDrmFormatModifierExplicitCreateInfoEXT & setDrmFormatModifierPlaneCount( uint32_t drmFormatModifierPlaneCount_ )
+    {
+      drmFormatModifierPlaneCount = drmFormatModifierPlaneCount_;
+      return *this;
+    }
+
+    ImageDrmFormatModifierExplicitCreateInfoEXT & setPPlaneLayouts( const SubresourceLayout* pPlaneLayouts_ )
+    {
+      pPlaneLayouts = pPlaneLayouts_;
+      return *this;
+    }
+
+    operator VkImageDrmFormatModifierExplicitCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>( this );
+    }
+
+    operator VkImageDrmFormatModifierExplicitCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>( this );
+    }
+
+    bool operator==( ImageDrmFormatModifierExplicitCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( drmFormatModifier == rhs.drmFormatModifier )
+          && ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount )
+          && ( pPlaneLayouts == rhs.pPlaneLayouts );
+    }
+
+    bool operator!=( ImageDrmFormatModifierExplicitCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    uint64_t drmFormatModifier;
+    uint32_t drmFormatModifierPlaneCount;
+    const SubresourceLayout* pPlaneLayouts;
+  };
+  static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct ImageDrmFormatModifierListCreateInfoEXT
+  {
+    ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0,
+                                             const uint64_t* pDrmFormatModifiers_ = nullptr )
+      : drmFormatModifierCount( drmFormatModifierCount_ )
+      , pDrmFormatModifiers( pDrmFormatModifiers_ )
+    {}
+
+    ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) );
+    }
+
+    ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) );
+      return *this;
+    }
+
+    ImageDrmFormatModifierListCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImageDrmFormatModifierListCreateInfoEXT & setDrmFormatModifierCount( uint32_t drmFormatModifierCount_ )
+    {
+      drmFormatModifierCount = drmFormatModifierCount_;
+      return *this;
+    }
+
+    ImageDrmFormatModifierListCreateInfoEXT & setPDrmFormatModifiers( const uint64_t* pDrmFormatModifiers_ )
+    {
+      pDrmFormatModifiers = pDrmFormatModifiers_;
+      return *this;
+    }
+
+    operator VkImageDrmFormatModifierListCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>( this );
+    }
+
+    operator VkImageDrmFormatModifierListCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>( this );
+    }
+
+    bool operator==( ImageDrmFormatModifierListCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( drmFormatModifierCount == rhs.drmFormatModifierCount )
+          && ( pDrmFormatModifiers == rhs.pDrmFormatModifiers );
+    }
+
+    bool operator!=( ImageDrmFormatModifierListCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t drmFormatModifierCount;
+    const uint64_t* pDrmFormatModifiers;
+  };
+  static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct ImageDrmFormatModifierPropertiesEXT
+  {
+    operator VkImageDrmFormatModifierPropertiesEXT const&() const
+    {
+      return *reinterpret_cast<const VkImageDrmFormatModifierPropertiesEXT*>( this );
+    }
+
+    operator VkImageDrmFormatModifierPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( this );
+    }
+
+    bool operator==( ImageDrmFormatModifierPropertiesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( drmFormatModifier == rhs.drmFormatModifier );
+    }
+
+    bool operator!=( ImageDrmFormatModifierPropertiesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT;
+
+  public:
+    void* pNext = nullptr;
+    uint64_t drmFormatModifier;
+  };
+  static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
+
+  struct ImageFormatListCreateInfoKHR
+  {
+    ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0,
+                                  const Format* pViewFormats_ = nullptr )
+      : viewFormatCount( viewFormatCount_ )
+      , pViewFormats( pViewFormats_ )
+    {}
+
+    ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) );
+    }
+
+    ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) );
+      return *this;
+    }
+
+    ImageFormatListCreateInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImageFormatListCreateInfoKHR & setViewFormatCount( uint32_t viewFormatCount_ )
+    {
+      viewFormatCount = viewFormatCount_;
+      return *this;
+    }
+
+    ImageFormatListCreateInfoKHR & setPViewFormats( const Format* pViewFormats_ )
+    {
+      pViewFormats = pViewFormats_;
+      return *this;
+    }
+
+    operator VkImageFormatListCreateInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkImageFormatListCreateInfoKHR*>( this );
+    }
+
+    operator VkImageFormatListCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkImageFormatListCreateInfoKHR*>( this );
+    }
+
+    bool operator==( ImageFormatListCreateInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( viewFormatCount == rhs.viewFormatCount )
+          && ( pViewFormats == rhs.pViewFormats );
+    }
+
+    bool operator!=( ImageFormatListCreateInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageFormatListCreateInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t viewFormatCount;
+    const Format* pViewFormats;
+  };
+  static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "struct and wrapper have different size!" );
+
+  struct ImageFormatProperties2
+  {
+    operator VkImageFormatProperties2 const&() const
+    {
+      return *reinterpret_cast<const VkImageFormatProperties2*>( this );
+    }
+
+    operator VkImageFormatProperties2 &()
+    {
+      return *reinterpret_cast<VkImageFormatProperties2*>( this );
+    }
+
+    bool operator==( ImageFormatProperties2 const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( imageFormatProperties == rhs.imageFormatProperties );
+    }
+
+    bool operator!=( ImageFormatProperties2 const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageFormatProperties2;
+
+  public:
+    void* pNext = nullptr;
+    ImageFormatProperties imageFormatProperties;
+  };
+  static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "struct and wrapper have different size!" );
+
+  struct ImageSubresourceRange
+  {
+    ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
+                           uint32_t baseMipLevel_ = 0,
+                           uint32_t levelCount_ = 0,
+                           uint32_t baseArrayLayer_ = 0,
+                           uint32_t layerCount_ = 0 )
+      : aspectMask( aspectMask_ )
+      , baseMipLevel( baseMipLevel_ )
+      , levelCount( levelCount_ )
+      , baseArrayLayer( baseArrayLayer_ )
+      , layerCount( layerCount_ )
+    {}
+
+    ImageSubresourceRange( VkImageSubresourceRange const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
+    }
+
+    ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
+      return *this;
+    }
+
+    ImageSubresourceRange & setAspectMask( ImageAspectFlags aspectMask_ )
+    {
+      aspectMask = aspectMask_;
+      return *this;
+    }
+
+    ImageSubresourceRange & setBaseMipLevel( uint32_t baseMipLevel_ )
+    {
+      baseMipLevel = baseMipLevel_;
+      return *this;
+    }
+
+    ImageSubresourceRange & setLevelCount( uint32_t levelCount_ )
+    {
+      levelCount = levelCount_;
+      return *this;
+    }
+
+    ImageSubresourceRange & setBaseArrayLayer( uint32_t baseArrayLayer_ )
+    {
+      baseArrayLayer = baseArrayLayer_;
+      return *this;
+    }
+
+    ImageSubresourceRange & setLayerCount( uint32_t layerCount_ )
+    {
+      layerCount = layerCount_;
+      return *this;
+    }
+
+    operator VkImageSubresourceRange const&() const
+    {
+      return *reinterpret_cast<const VkImageSubresourceRange*>( this );
+    }
+
+    operator VkImageSubresourceRange &()
+    {
+      return *reinterpret_cast<VkImageSubresourceRange*>( this );
+    }
+
+    bool operator==( ImageSubresourceRange const& rhs ) const
+    {
+      return ( aspectMask == rhs.aspectMask )
+          && ( baseMipLevel == rhs.baseMipLevel )
+          && ( levelCount == rhs.levelCount )
+          && ( baseArrayLayer == rhs.baseArrayLayer )
+          && ( layerCount == rhs.layerCount );
+    }
+
+    bool operator!=( ImageSubresourceRange const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ImageAspectFlags aspectMask;
+    uint32_t baseMipLevel;
+    uint32_t levelCount;
+    uint32_t baseArrayLayer;
+    uint32_t layerCount;
+  };
+  static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" );
+
+  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() )
+      : srcAccessMask( srcAccessMask_ )
+      , dstAccessMask( dstAccessMask_ )
+      , oldLayout( oldLayout_ )
+      , newLayout( newLayout_ )
+      , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
+      , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
+      , image( image_ )
+      , subresourceRange( subresourceRange_ )
+    {}
+
+    ImageMemoryBarrier( VkImageMemoryBarrier const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
+    }
+
+    ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
+      return *this;
+    }
+
+    ImageMemoryBarrier & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImageMemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ )
+    {
+      srcAccessMask = srcAccessMask_;
+      return *this;
+    }
+
+    ImageMemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ )
+    {
+      dstAccessMask = dstAccessMask_;
+      return *this;
+    }
+
+    ImageMemoryBarrier & setOldLayout( ImageLayout oldLayout_ )
+    {
+      oldLayout = oldLayout_;
+      return *this;
+    }
+
+    ImageMemoryBarrier & setNewLayout( ImageLayout newLayout_ )
+    {
+      newLayout = newLayout_;
+      return *this;
+    }
+
+    ImageMemoryBarrier & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
+    {
+      srcQueueFamilyIndex = srcQueueFamilyIndex_;
+      return *this;
+    }
+
+    ImageMemoryBarrier & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
+    {
+      dstQueueFamilyIndex = dstQueueFamilyIndex_;
+      return *this;
+    }
+
+    ImageMemoryBarrier & setImage( Image image_ )
+    {
+      image = image_;
+      return *this;
+    }
+
+    ImageMemoryBarrier & setSubresourceRange( ImageSubresourceRange subresourceRange_ )
+    {
+      subresourceRange = subresourceRange_;
+      return *this;
+    }
+
+    operator VkImageMemoryBarrier const&() const
+    {
+      return *reinterpret_cast<const VkImageMemoryBarrier*>( this );
+    }
+
+    operator VkImageMemoryBarrier &()
+    {
+      return *reinterpret_cast<VkImageMemoryBarrier*>( this );
+    }
+
+    bool operator==( ImageMemoryBarrier const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( srcAccessMask == rhs.srcAccessMask )
+          && ( dstAccessMask == rhs.dstAccessMask )
+          && ( oldLayout == rhs.oldLayout )
+          && ( newLayout == rhs.newLayout )
+          && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
+          && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
+          && ( image == rhs.image )
+          && ( subresourceRange == rhs.subresourceRange );
+    }
+
+    bool operator!=( ImageMemoryBarrier const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageMemoryBarrier;
+
+  public:
+    const void* pNext = nullptr;
+    AccessFlags srcAccessMask;
+    AccessFlags dstAccessMask;
+    ImageLayout oldLayout;
+    ImageLayout newLayout;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    Image image;
+    ImageSubresourceRange subresourceRange;
+  };
+  static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" );
+
+  struct ImageMemoryRequirementsInfo2
+  {
+    ImageMemoryRequirementsInfo2( Image image_ = Image() )
+      : image( image_ )
+    {}
+
+    ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2 ) );
+    }
+
+    ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2 ) );
+      return *this;
+    }
+
+    ImageMemoryRequirementsInfo2 & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImageMemoryRequirementsInfo2 & setImage( Image image_ )
+    {
+      image = image_;
+      return *this;
+    }
+
+    operator VkImageMemoryRequirementsInfo2 const&() const
+    {
+      return *reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( this );
+    }
+
+    operator VkImageMemoryRequirementsInfo2 &()
+    {
+      return *reinterpret_cast<VkImageMemoryRequirementsInfo2*>( this );
+    }
+
+    bool operator==( ImageMemoryRequirementsInfo2 const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( image == rhs.image );
+    }
+
+    bool operator!=( ImageMemoryRequirementsInfo2 const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageMemoryRequirementsInfo2;
+
+  public:
+    const void* pNext = nullptr;
+    Image image;
+  };
+  static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+  struct ImagePipeSurfaceCreateInfoFUCHSIA
+  {
+    ImagePipeSurfaceCreateInfoFUCHSIA( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = ImagePipeSurfaceCreateFlagsFUCHSIA(),
+                                       zx_handle_t imagePipeHandle_ = 0 )
+      : flags( flags_ )
+      , imagePipeHandle( imagePipeHandle_ )
+    {}
+
+    ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) );
+    }
+
+    ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) );
+      return *this;
+    }
+
+    ImagePipeSurfaceCreateInfoFUCHSIA & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImagePipeSurfaceCreateInfoFUCHSIA & setFlags( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ImagePipeSurfaceCreateInfoFUCHSIA & setImagePipeHandle( zx_handle_t imagePipeHandle_ )
+    {
+      imagePipeHandle = imagePipeHandle_;
+      return *this;
+    }
+
+    operator VkImagePipeSurfaceCreateInfoFUCHSIA const&() const
+    {
+      return *reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( this );
+    }
+
+    operator VkImagePipeSurfaceCreateInfoFUCHSIA &()
+    {
+      return *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>( this );
+    }
+
+    bool operator==( ImagePipeSurfaceCreateInfoFUCHSIA const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( imagePipeHandle == rhs.imagePipeHandle );
+    }
+
+    bool operator!=( ImagePipeSurfaceCreateInfoFUCHSIA const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA;
+
+  public:
+    const void* pNext = nullptr;
+    ImagePipeSurfaceCreateFlagsFUCHSIA flags;
+    zx_handle_t imagePipeHandle;
+  };
+  static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+  struct ImagePlaneMemoryRequirementsInfo
+  {
+    ImagePlaneMemoryRequirementsInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
+      : planeAspect( planeAspect_ )
+    {}
+
+    ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) );
+    }
+
+    ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) );
+      return *this;
+    }
+
+    ImagePlaneMemoryRequirementsInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImagePlaneMemoryRequirementsInfo & setPlaneAspect( ImageAspectFlagBits planeAspect_ )
+    {
+      planeAspect = planeAspect_;
+      return *this;
+    }
+
+    operator VkImagePlaneMemoryRequirementsInfo const&() const
+    {
+      return *reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>( this );
+    }
+
+    operator VkImagePlaneMemoryRequirementsInfo &()
+    {
+      return *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>( this );
+    }
+
+    bool operator==( ImagePlaneMemoryRequirementsInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( planeAspect == rhs.planeAspect );
+    }
+
+    bool operator!=( ImagePlaneMemoryRequirementsInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo;
+
+  public:
+    const void* pNext = nullptr;
+    ImageAspectFlagBits planeAspect;
+  };
+  static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "struct and wrapper have different size!" );
+
+  struct ImageResolve
+  {
+    ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
+                  Offset3D srcOffset_ = Offset3D(),
+                  ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
+                  Offset3D dstOffset_ = Offset3D(),
+                  Extent3D extent_ = Extent3D() )
+      : srcSubresource( srcSubresource_ )
+      , srcOffset( srcOffset_ )
+      , dstSubresource( dstSubresource_ )
+      , dstOffset( dstOffset_ )
+      , extent( extent_ )
+    {}
+
+    ImageResolve( VkImageResolve const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageResolve ) );
+    }
+
+    ImageResolve& operator=( VkImageResolve const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageResolve ) );
+      return *this;
+    }
+
+    ImageResolve & setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+    {
+      srcSubresource = srcSubresource_;
+      return *this;
+    }
+
+    ImageResolve & setSrcOffset( Offset3D srcOffset_ )
+    {
+      srcOffset = srcOffset_;
+      return *this;
+    }
+
+    ImageResolve & setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+    {
+      dstSubresource = dstSubresource_;
+      return *this;
+    }
+
+    ImageResolve & setDstOffset( Offset3D dstOffset_ )
+    {
+      dstOffset = dstOffset_;
+      return *this;
+    }
+
+    ImageResolve & setExtent( Extent3D extent_ )
+    {
+      extent = extent_;
+      return *this;
+    }
+
+    operator VkImageResolve const&() const
+    {
+      return *reinterpret_cast<const VkImageResolve*>( this );
+    }
+
+    operator VkImageResolve &()
+    {
+      return *reinterpret_cast<VkImageResolve*>( this );
+    }
+
+    bool operator==( ImageResolve const& rhs ) const
+    {
+      return ( srcSubresource == rhs.srcSubresource )
+          && ( srcOffset == rhs.srcOffset )
+          && ( dstSubresource == rhs.dstSubresource )
+          && ( dstOffset == rhs.dstOffset )
+          && ( extent == rhs.extent );
+    }
+
+    bool operator!=( ImageResolve const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ImageSubresourceLayers srcSubresource;
+    Offset3D srcOffset;
+    ImageSubresourceLayers dstSubresource;
+    Offset3D dstOffset;
+    Extent3D extent;
+  };
+  static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" );
+
+  struct ImageSparseMemoryRequirementsInfo2
+  {
+    ImageSparseMemoryRequirementsInfo2( Image image_ = Image() )
+      : image( image_ )
+    {}
+
+    ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2 ) );
+    }
+
+    ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2 ) );
+      return *this;
+    }
+
+    ImageSparseMemoryRequirementsInfo2 & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImageSparseMemoryRequirementsInfo2 & setImage( Image image_ )
+    {
+      image = image_;
+      return *this;
+    }
+
+    operator VkImageSparseMemoryRequirementsInfo2 const&() const
+    {
+      return *reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( this );
+    }
+
+    operator VkImageSparseMemoryRequirementsInfo2 &()
+    {
+      return *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>( this );
+    }
+
+    bool operator==( ImageSparseMemoryRequirementsInfo2 const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( image == rhs.image );
+    }
+
+    bool operator!=( ImageSparseMemoryRequirementsInfo2 const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2;
+
+  public:
+    const void* pNext = nullptr;
+    Image image;
+  };
+  static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
+
+  struct ImageStencilUsageCreateInfoEXT
+  {
+    ImageStencilUsageCreateInfoEXT( ImageUsageFlags stencilUsage_ = ImageUsageFlags() )
+      : stencilUsage( stencilUsage_ )
+    {}
+
+    ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageStencilUsageCreateInfoEXT ) );
+    }
+
+    ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageStencilUsageCreateInfoEXT ) );
+      return *this;
+    }
+
+    ImageStencilUsageCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImageStencilUsageCreateInfoEXT & setStencilUsage( ImageUsageFlags stencilUsage_ )
+    {
+      stencilUsage = stencilUsage_;
+      return *this;
+    }
+
+    operator VkImageStencilUsageCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkImageStencilUsageCreateInfoEXT*>( this );
+    }
+
+    operator VkImageStencilUsageCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkImageStencilUsageCreateInfoEXT*>( this );
+    }
+
+    bool operator==( ImageStencilUsageCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( stencilUsage == rhs.stencilUsage );
+    }
+
+    bool operator!=( ImageStencilUsageCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageStencilUsageCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    ImageUsageFlags stencilUsage;
+  };
+  static_assert( sizeof( ImageStencilUsageCreateInfoEXT ) == sizeof( VkImageStencilUsageCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct ImageSwapchainCreateInfoKHR
+  {
+    ImageSwapchainCreateInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR() )
+      : swapchain( swapchain_ )
+    {}
+
+    ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHR ) );
+    }
+
+    ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHR ) );
+      return *this;
+    }
+
+    ImageSwapchainCreateInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImageSwapchainCreateInfoKHR & setSwapchain( SwapchainKHR swapchain_ )
+    {
+      swapchain = swapchain_;
+      return *this;
+    }
+
+    operator VkImageSwapchainCreateInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>( this );
+    }
+
+    operator VkImageSwapchainCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>( this );
+    }
+
+    bool operator==( ImageSwapchainCreateInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( swapchain == rhs.swapchain );
+    }
+
+    bool operator!=( ImageSwapchainCreateInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageSwapchainCreateInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    SwapchainKHR swapchain;
+  };
+  static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
+
+  struct ImageViewASTCDecodeModeEXT
+  {
+    ImageViewASTCDecodeModeEXT( Format decodeMode_ = Format::eUndefined )
+      : decodeMode( decodeMode_ )
+    {}
+
+    ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageViewASTCDecodeModeEXT ) );
+    }
+
+    ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageViewASTCDecodeModeEXT ) );
+      return *this;
+    }
+
+    ImageViewASTCDecodeModeEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImageViewASTCDecodeModeEXT & setDecodeMode( Format decodeMode_ )
+    {
+      decodeMode = decodeMode_;
+      return *this;
+    }
+
+    operator VkImageViewASTCDecodeModeEXT const&() const
+    {
+      return *reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>( this );
+    }
+
+    operator VkImageViewASTCDecodeModeEXT &()
+    {
+      return *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>( this );
+    }
+
+    bool operator==( ImageViewASTCDecodeModeEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( decodeMode == rhs.decodeMode );
+    }
+
+    bool operator!=( ImageViewASTCDecodeModeEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageViewAstcDecodeModeEXT;
+
+  public:
+    const void* pNext = nullptr;
+    Format decodeMode;
+  };
+  static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "struct and wrapper have different size!" );
+
+  struct ImageViewCreateInfo
+  {
+    ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(),
+                         Image image_ = Image(),
+                         ImageViewType viewType_ = ImageViewType::e1D,
+                         Format format_ = Format::eUndefined,
+                         ComponentMapping components_ = ComponentMapping(),
+                         ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
+      : flags( flags_ )
+      , image( image_ )
+      , viewType( viewType_ )
+      , format( format_ )
+      , components( components_ )
+      , subresourceRange( subresourceRange_ )
+    {}
+
+    ImageViewCreateInfo( VkImageViewCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
+    }
+
+    ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
+      return *this;
+    }
+
+    ImageViewCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImageViewCreateInfo & setFlags( ImageViewCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ImageViewCreateInfo & setImage( Image image_ )
+    {
+      image = image_;
+      return *this;
+    }
+
+    ImageViewCreateInfo & setViewType( ImageViewType viewType_ )
+    {
+      viewType = viewType_;
+      return *this;
+    }
+
+    ImageViewCreateInfo & setFormat( Format format_ )
+    {
+      format = format_;
+      return *this;
+    }
+
+    ImageViewCreateInfo & setComponents( ComponentMapping components_ )
+    {
+      components = components_;
+      return *this;
+    }
+
+    ImageViewCreateInfo & setSubresourceRange( ImageSubresourceRange subresourceRange_ )
+    {
+      subresourceRange = subresourceRange_;
+      return *this;
+    }
+
+    operator VkImageViewCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkImageViewCreateInfo*>( this );
+    }
+
+    operator VkImageViewCreateInfo &()
+    {
+      return *reinterpret_cast<VkImageViewCreateInfo*>( this );
+    }
+
+    bool operator==( ImageViewCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( image == rhs.image )
+          && ( viewType == rhs.viewType )
+          && ( format == rhs.format )
+          && ( components == rhs.components )
+          && ( subresourceRange == rhs.subresourceRange );
+    }
+
+    bool operator!=( ImageViewCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageViewCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    ImageViewCreateFlags flags;
+    Image image;
+    ImageViewType viewType;
+    Format format;
+    ComponentMapping components;
+    ImageSubresourceRange subresourceRange;
+  };
+  static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" );
+
+  struct ImageViewUsageCreateInfo
+  {
+    ImageViewUsageCreateInfo( ImageUsageFlags usage_ = ImageUsageFlags() )
+      : usage( usage_ )
+    {}
+
+    ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) );
+    }
+
+    ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) );
+      return *this;
+    }
+
+    ImageViewUsageCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImageViewUsageCreateInfo & setUsage( ImageUsageFlags usage_ )
+    {
+      usage = usage_;
+      return *this;
+    }
+
+    operator VkImageViewUsageCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkImageViewUsageCreateInfo*>( this );
+    }
+
+    operator VkImageViewUsageCreateInfo &()
+    {
+      return *reinterpret_cast<VkImageViewUsageCreateInfo*>( this );
+    }
+
+    bool operator==( ImageViewUsageCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( usage == rhs.usage );
+    }
+
+    bool operator!=( ImageViewUsageCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImageViewUsageCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    ImageUsageFlags usage;
+  };
+  static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  struct ImportAndroidHardwareBufferInfoANDROID
+  {
+    ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr )
+      : buffer( buffer_ )
+    {}
+
+    ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportAndroidHardwareBufferInfoANDROID ) );
+    }
+
+    ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportAndroidHardwareBufferInfoANDROID ) );
+      return *this;
+    }
+
+    ImportAndroidHardwareBufferInfoANDROID & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImportAndroidHardwareBufferInfoANDROID & setBuffer( struct AHardwareBuffer* buffer_ )
+    {
+      buffer = buffer_;
+      return *this;
+    }
+
+    operator VkImportAndroidHardwareBufferInfoANDROID const&() const
+    {
+      return *reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>( this );
+    }
+
+    operator VkImportAndroidHardwareBufferInfoANDROID &()
+    {
+      return *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>( this );
+    }
+
+    bool operator==( ImportAndroidHardwareBufferInfoANDROID const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( buffer == rhs.buffer );
+    }
+
+    bool operator!=( ImportAndroidHardwareBufferInfoANDROID const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID;
+
+  public:
+    const void* pNext = nullptr;
+    struct AHardwareBuffer* buffer;
+  };
+  static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+  struct ImportFenceFdInfoKHR
+  {
+    ImportFenceFdInfoKHR( Fence fence_ = Fence(),
+                          FenceImportFlags flags_ = FenceImportFlags(),
+                          ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd,
+                          int fd_ = 0 )
+      : fence( fence_ )
+      , flags( flags_ )
+      , handleType( handleType_ )
+      , fd( fd_ )
+    {}
+
+    ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
+    }
+
+    ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
+      return *this;
+    }
+
+    ImportFenceFdInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImportFenceFdInfoKHR & setFence( Fence fence_ )
+    {
+      fence = fence_;
+      return *this;
+    }
+
+    ImportFenceFdInfoKHR & setFlags( FenceImportFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ImportFenceFdInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    ImportFenceFdInfoKHR & setFd( int fd_ )
+    {
+      fd = fd_;
+      return *this;
+    }
+
+    operator VkImportFenceFdInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkImportFenceFdInfoKHR*>( this );
+    }
+
+    operator VkImportFenceFdInfoKHR &()
+    {
+      return *reinterpret_cast<VkImportFenceFdInfoKHR*>( this );
+    }
+
+    bool operator==( ImportFenceFdInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( fence == rhs.fence )
+          && ( flags == rhs.flags )
+          && ( handleType == rhs.handleType )
+          && ( fd == rhs.fd );
+    }
+
+    bool operator!=( ImportFenceFdInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImportFenceFdInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    Fence fence;
+    FenceImportFlags flags;
+    ExternalFenceHandleTypeFlagBits handleType;
+    int fd;
+  };
+  static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct ImportFenceWin32HandleInfoKHR
+  {
+    ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(),
+                                   FenceImportFlags flags_ = FenceImportFlags(),
+                                   ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd,
+                                   HANDLE handle_ = 0,
+                                   LPCWSTR name_ = nullptr )
+      : fence( fence_ )
+      , flags( flags_ )
+      , handleType( handleType_ )
+      , handle( handle_ )
+      , name( name_ )
+    {}
+
+    ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
+    }
+
+    ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
+      return *this;
+    }
+
+    ImportFenceWin32HandleInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImportFenceWin32HandleInfoKHR & setFence( Fence fence_ )
+    {
+      fence = fence_;
+      return *this;
+    }
+
+    ImportFenceWin32HandleInfoKHR & setFlags( FenceImportFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ImportFenceWin32HandleInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    ImportFenceWin32HandleInfoKHR & setHandle( HANDLE handle_ )
+    {
+      handle = handle_;
+      return *this;
+    }
+
+    ImportFenceWin32HandleInfoKHR & setName( LPCWSTR name_ )
+    {
+      name = name_;
+      return *this;
+    }
+
+    operator VkImportFenceWin32HandleInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( this );
+    }
+
+    operator VkImportFenceWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>( this );
+    }
+
+    bool operator==( ImportFenceWin32HandleInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( fence == rhs.fence )
+          && ( flags == rhs.flags )
+          && ( handleType == rhs.handleType )
+          && ( handle == rhs.handle )
+          && ( name == rhs.name );
+    }
+
+    bool operator!=( ImportFenceWin32HandleInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    Fence fence;
+    FenceImportFlags flags;
+    ExternalFenceHandleTypeFlagBits handleType;
+    HANDLE handle;
+    LPCWSTR name;
+  };
+  static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  struct ImportMemoryFdInfoKHR
+  {
+    ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+                           int fd_ = 0 )
+      : handleType( handleType_ )
+      , fd( fd_ )
+    {}
+
+    ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
+    }
+
+    ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
+      return *this;
+    }
+
+    ImportMemoryFdInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImportMemoryFdInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    ImportMemoryFdInfoKHR & setFd( int fd_ )
+    {
+      fd = fd_;
+      return *this;
+    }
+
+    operator VkImportMemoryFdInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkImportMemoryFdInfoKHR*>( this );
+    }
+
+    operator VkImportMemoryFdInfoKHR &()
+    {
+      return *reinterpret_cast<VkImportMemoryFdInfoKHR*>( this );
+    }
+
+    bool operator==( ImportMemoryFdInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( handleType == rhs.handleType )
+          && ( fd == rhs.fd );
+    }
+
+    bool operator!=( ImportMemoryFdInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImportMemoryFdInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    ExternalMemoryHandleTypeFlagBits handleType;
+    int fd;
+  };
+  static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" );
+
+  struct ImportMemoryHostPointerInfoEXT
+  {
+    ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+                                    void* pHostPointer_ = nullptr )
+      : handleType( handleType_ )
+      , pHostPointer( pHostPointer_ )
+    {}
+
+    ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
+    }
+
+    ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
+      return *this;
+    }
+
+    ImportMemoryHostPointerInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImportMemoryHostPointerInfoEXT & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    ImportMemoryHostPointerInfoEXT & setPHostPointer( void* pHostPointer_ )
+    {
+      pHostPointer = pHostPointer_;
+      return *this;
+    }
+
+    operator VkImportMemoryHostPointerInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>( this );
+    }
+
+    operator VkImportMemoryHostPointerInfoEXT &()
+    {
+      return *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>( this );
+    }
+
+    bool operator==( ImportMemoryHostPointerInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( handleType == rhs.handleType )
+          && ( pHostPointer == rhs.pHostPointer );
+    }
+
+    bool operator!=( ImportMemoryHostPointerInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    ExternalMemoryHandleTypeFlagBits handleType;
+    void* pHostPointer;
+  };
+  static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct ImportMemoryWin32HandleInfoKHR
+  {
+    ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+                                    HANDLE handle_ = 0,
+                                    LPCWSTR name_ = nullptr )
+      : handleType( handleType_ )
+      , handle( handle_ )
+      , name( name_ )
+    {}
+
+    ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
+    }
+
+    ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
+      return *this;
+    }
+
+    ImportMemoryWin32HandleInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImportMemoryWin32HandleInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    ImportMemoryWin32HandleInfoKHR & setHandle( HANDLE handle_ )
+    {
+      handle = handle_;
+      return *this;
+    }
+
+    ImportMemoryWin32HandleInfoKHR & setName( LPCWSTR name_ )
+    {
+      name = name_;
+      return *this;
+    }
+
+    operator VkImportMemoryWin32HandleInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>( this );
+    }
+
+    operator VkImportMemoryWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>( this );
+    }
+
+    bool operator==( ImportMemoryWin32HandleInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( handleType == rhs.handleType )
+          && ( handle == rhs.handle )
+          && ( name == rhs.name );
+    }
+
+    bool operator!=( ImportMemoryWin32HandleInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    ExternalMemoryHandleTypeFlagBits handleType;
+    HANDLE handle;
+    LPCWSTR name;
+  };
+  static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct ImportMemoryWin32HandleInfoNV
+  {
+    ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(),
+                                   HANDLE handle_ = 0 )
+      : handleType( handleType_ )
+      , handle( handle_ )
+    {}
+
+    ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
+    }
+
+    ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
+      return *this;
+    }
+
+    ImportMemoryWin32HandleInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImportMemoryWin32HandleInfoNV & setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    ImportMemoryWin32HandleInfoNV & setHandle( HANDLE handle_ )
+    {
+      handle = handle_;
+      return *this;
+    }
+
+    operator VkImportMemoryWin32HandleInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>( this );
+    }
+
+    operator VkImportMemoryWin32HandleInfoNV &()
+    {
+      return *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>( this );
+    }
+
+    bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( handleType == rhs.handleType )
+          && ( handle == rhs.handle );
+    }
+
+    bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    ExternalMemoryHandleTypeFlagsNV handleType;
+    HANDLE handle;
+  };
+  static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  struct ImportSemaphoreFdInfoKHR
+  {
+    ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(),
+                              SemaphoreImportFlags flags_ = SemaphoreImportFlags(),
+                              ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
+                              int fd_ = 0 )
+      : semaphore( semaphore_ )
+      , flags( flags_ )
+      , handleType( handleType_ )
+      , fd( fd_ )
+    {}
+
+    ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
+    }
+
+    ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
+      return *this;
+    }
+
+    ImportSemaphoreFdInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImportSemaphoreFdInfoKHR & setSemaphore( Semaphore semaphore_ )
+    {
+      semaphore = semaphore_;
+      return *this;
+    }
+
+    ImportSemaphoreFdInfoKHR & setFlags( SemaphoreImportFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ImportSemaphoreFdInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    ImportSemaphoreFdInfoKHR & setFd( int fd_ )
+    {
+      fd = fd_;
+      return *this;
+    }
+
+    operator VkImportSemaphoreFdInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( this );
+    }
+
+    operator VkImportSemaphoreFdInfoKHR &()
+    {
+      return *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>( this );
+    }
+
+    bool operator==( ImportSemaphoreFdInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( semaphore == rhs.semaphore )
+          && ( flags == rhs.flags )
+          && ( handleType == rhs.handleType )
+          && ( fd == rhs.fd );
+    }
+
+    bool operator!=( ImportSemaphoreFdInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImportSemaphoreFdInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    Semaphore semaphore;
+    SemaphoreImportFlags flags;
+    ExternalSemaphoreHandleTypeFlagBits handleType;
+    int fd;
+  };
+  static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct ImportSemaphoreWin32HandleInfoKHR
+  {
+    ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
+                                       SemaphoreImportFlags flags_ = SemaphoreImportFlags(),
+                                       ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
+                                       HANDLE handle_ = 0,
+                                       LPCWSTR name_ = nullptr )
+      : semaphore( semaphore_ )
+      , flags( flags_ )
+      , handleType( handleType_ )
+      , handle( handle_ )
+      , name( name_ )
+    {}
+
+    ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
+    }
+
+    ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
+      return *this;
+    }
+
+    ImportSemaphoreWin32HandleInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ImportSemaphoreWin32HandleInfoKHR & setSemaphore( Semaphore semaphore_ )
+    {
+      semaphore = semaphore_;
+      return *this;
+    }
+
+    ImportSemaphoreWin32HandleInfoKHR & setFlags( SemaphoreImportFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ImportSemaphoreWin32HandleInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    ImportSemaphoreWin32HandleInfoKHR & setHandle( HANDLE handle_ )
+    {
+      handle = handle_;
+      return *this;
+    }
+
+    ImportSemaphoreWin32HandleInfoKHR & setName( LPCWSTR name_ )
+    {
+      name = name_;
+      return *this;
+    }
+
+    operator VkImportSemaphoreWin32HandleInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( this );
+    }
+
+    operator VkImportSemaphoreWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>( this );
+    }
+
+    bool operator==( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( semaphore == rhs.semaphore )
+          && ( flags == rhs.flags )
+          && ( handleType == rhs.handleType )
+          && ( handle == rhs.handle )
+          && ( name == rhs.name );
+    }
+
+    bool operator!=( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    Semaphore semaphore;
+    SemaphoreImportFlags flags;
+    ExternalSemaphoreHandleTypeFlagBits handleType;
+    HANDLE handle;
+    LPCWSTR name;
+  };
+  static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  struct IndirectCommandsLayoutTokenNVX
+  {
+    IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline,
+                                    uint32_t bindingUnit_ = 0,
+                                    uint32_t dynamicCount_ = 0,
+                                    uint32_t divisor_ = 0 )
+      : tokenType( tokenType_ )
+      , bindingUnit( bindingUnit_ )
+      , dynamicCount( dynamicCount_ )
+      , divisor( divisor_ )
+    {}
+
+    IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
+    }
+
+    IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
+      return *this;
+    }
+
+    IndirectCommandsLayoutTokenNVX & setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
+    {
+      tokenType = tokenType_;
+      return *this;
+    }
+
+    IndirectCommandsLayoutTokenNVX & setBindingUnit( uint32_t bindingUnit_ )
+    {
+      bindingUnit = bindingUnit_;
+      return *this;
+    }
+
+    IndirectCommandsLayoutTokenNVX & setDynamicCount( uint32_t dynamicCount_ )
+    {
+      dynamicCount = dynamicCount_;
+      return *this;
+    }
+
+    IndirectCommandsLayoutTokenNVX & setDivisor( uint32_t divisor_ )
+    {
+      divisor = divisor_;
+      return *this;
+    }
+
+    operator VkIndirectCommandsLayoutTokenNVX const&() const
+    {
+      return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNVX*>( this );
+    }
+
+    operator VkIndirectCommandsLayoutTokenNVX &()
+    {
+      return *reinterpret_cast<VkIndirectCommandsLayoutTokenNVX*>( this );
+    }
+
+    bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const
+    {
+      return ( tokenType == rhs.tokenType )
+          && ( bindingUnit == rhs.bindingUnit )
+          && ( dynamicCount == rhs.dynamicCount )
+          && ( divisor == rhs.divisor );
+    }
+
+    bool operator!=( IndirectCommandsLayoutTokenNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    IndirectCommandsTokenTypeNVX tokenType;
+    uint32_t bindingUnit;
+    uint32_t dynamicCount;
+    uint32_t divisor;
+  };
+  static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" );
+
+  struct IndirectCommandsLayoutCreateInfoNVX
+  {
+    IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
+                                         IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(),
+                                         uint32_t tokenCount_ = 0,
+                                         const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
+      : pipelineBindPoint( pipelineBindPoint_ )
+      , flags( flags_ )
+      , tokenCount( tokenCount_ )
+      , pTokens( pTokens_ )
+    {}
+
+    IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
+    }
+
+    IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
+      return *this;
+    }
+
+    IndirectCommandsLayoutCreateInfoNVX & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    IndirectCommandsLayoutCreateInfoNVX & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+    {
+      pipelineBindPoint = pipelineBindPoint_;
+      return *this;
+    }
+
+    IndirectCommandsLayoutCreateInfoNVX & setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    IndirectCommandsLayoutCreateInfoNVX & setTokenCount( uint32_t tokenCount_ )
+    {
+      tokenCount = tokenCount_;
+      return *this;
+    }
+
+    IndirectCommandsLayoutCreateInfoNVX & setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ )
+    {
+      pTokens = pTokens_;
+      return *this;
+    }
+
+    operator VkIndirectCommandsLayoutCreateInfoNVX const&() const
+    {
+      return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( this );
+    }
+
+    operator VkIndirectCommandsLayoutCreateInfoNVX &()
+    {
+      return *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX*>( this );
+    }
+
+    bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( pipelineBindPoint == rhs.pipelineBindPoint )
+          && ( flags == rhs.flags )
+          && ( tokenCount == rhs.tokenCount )
+          && ( pTokens == rhs.pTokens );
+    }
+
+    bool operator!=( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX;
+
+  public:
+    const void* pNext = nullptr;
+    PipelineBindPoint pipelineBindPoint;
+    IndirectCommandsLayoutUsageFlagsNVX flags;
+    uint32_t tokenCount;
+    const IndirectCommandsLayoutTokenNVX* pTokens;
+  };
+  static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" );
+
+  struct InputAttachmentAspectReference
+  {
+    InputAttachmentAspectReference( uint32_t subpass_ = 0,
+                                    uint32_t inputAttachmentIndex_ = 0,
+                                    ImageAspectFlags aspectMask_ = ImageAspectFlags() )
+      : subpass( subpass_ )
+      , inputAttachmentIndex( inputAttachmentIndex_ )
+      , aspectMask( aspectMask_ )
+    {}
+
+    InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) );
+    }
+
+    InputAttachmentAspectReference& operator=( VkInputAttachmentAspectReference const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) );
+      return *this;
+    }
+
+    InputAttachmentAspectReference & setSubpass( uint32_t subpass_ )
+    {
+      subpass = subpass_;
+      return *this;
+    }
+
+    InputAttachmentAspectReference & setInputAttachmentIndex( uint32_t inputAttachmentIndex_ )
+    {
+      inputAttachmentIndex = inputAttachmentIndex_;
+      return *this;
+    }
+
+    InputAttachmentAspectReference & setAspectMask( ImageAspectFlags aspectMask_ )
+    {
+      aspectMask = aspectMask_;
+      return *this;
+    }
+
+    operator VkInputAttachmentAspectReference const&() const
+    {
+      return *reinterpret_cast<const VkInputAttachmentAspectReference*>( this );
+    }
+
+    operator VkInputAttachmentAspectReference &()
+    {
+      return *reinterpret_cast<VkInputAttachmentAspectReference*>( this );
+    }
+
+    bool operator==( InputAttachmentAspectReference const& rhs ) const
+    {
+      return ( subpass == rhs.subpass )
+          && ( inputAttachmentIndex == rhs.inputAttachmentIndex )
+          && ( aspectMask == rhs.aspectMask );
+    }
+
+    bool operator!=( InputAttachmentAspectReference const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t subpass;
+    uint32_t inputAttachmentIndex;
+    ImageAspectFlags aspectMask;
+  };
+  static_assert( sizeof( InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), "struct and wrapper have different size!" );
+
+  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 )
+      : flags( flags_ )
+      , pApplicationInfo( pApplicationInfo_ )
+      , enabledLayerCount( enabledLayerCount_ )
+      , ppEnabledLayerNames( ppEnabledLayerNames_ )
+      , enabledExtensionCount( enabledExtensionCount_ )
+      , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
+    {}
+
+    InstanceCreateInfo( VkInstanceCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( InstanceCreateInfo ) );
+    }
+
+    InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( InstanceCreateInfo ) );
+      return *this;
+    }
+
+    InstanceCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    InstanceCreateInfo & setFlags( InstanceCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    InstanceCreateInfo & setPApplicationInfo( const ApplicationInfo* pApplicationInfo_ )
+    {
+      pApplicationInfo = pApplicationInfo_;
+      return *this;
+    }
+
+    InstanceCreateInfo & setEnabledLayerCount( uint32_t enabledLayerCount_ )
+    {
+      enabledLayerCount = enabledLayerCount_;
+      return *this;
+    }
+
+    InstanceCreateInfo & setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ )
+    {
+      ppEnabledLayerNames = ppEnabledLayerNames_;
+      return *this;
+    }
+
+    InstanceCreateInfo & setEnabledExtensionCount( uint32_t enabledExtensionCount_ )
+    {
+      enabledExtensionCount = enabledExtensionCount_;
+      return *this;
+    }
+
+    InstanceCreateInfo & setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ )
+    {
+      ppEnabledExtensionNames = ppEnabledExtensionNames_;
+      return *this;
+    }
+
+    operator VkInstanceCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkInstanceCreateInfo*>( this );
+    }
+
+    operator VkInstanceCreateInfo &()
+    {
+      return *reinterpret_cast<VkInstanceCreateInfo*>( this );
+    }
+
+    bool operator==( InstanceCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( pApplicationInfo == rhs.pApplicationInfo )
+          && ( enabledLayerCount == rhs.enabledLayerCount )
+          && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames )
+          && ( enabledExtensionCount == rhs.enabledExtensionCount )
+          && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames );
+    }
+
+    bool operator!=( InstanceCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eInstanceCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    InstanceCreateFlags flags;
+    const ApplicationInfo* pApplicationInfo;
+    uint32_t enabledLayerCount;
+    const char* const* ppEnabledLayerNames;
+    uint32_t enabledExtensionCount;
+    const char* const* ppEnabledExtensionNames;
+  };
+  static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" );
+
+  struct LayerProperties
+  {
+    operator VkLayerProperties const&() const
+    {
+      return *reinterpret_cast<const VkLayerProperties*>( this );
+    }
+
+    operator VkLayerProperties &()
+    {
+      return *reinterpret_cast<VkLayerProperties*>( this );
+    }
+
+    bool operator==( LayerProperties const& rhs ) const
+    {
+      return ( memcmp( layerName, rhs.layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
+          && ( specVersion == rhs.specVersion )
+          && ( implementationVersion == rhs.implementationVersion )
+          && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 );
+    }
+
+    bool operator!=( LayerProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    char layerName[VK_MAX_EXTENSION_NAME_SIZE];
+    uint32_t specVersion;
+    uint32_t implementationVersion;
+    char description[VK_MAX_DESCRIPTION_SIZE];
+  };
+  static_assert( sizeof( LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" );
+
 #ifdef VK_USE_PLATFORM_MACOS_MVK
   struct MacOSSurfaceCreateInfoMVK
   {
@@ -15148,8 +32678,7 @@ public:
                                const void* pView_ = nullptr )
       : flags( flags_ )
       , pView( pView_ )
-    {
-    }
+    {}
 
     MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs )
     {
@@ -15161,19 +32690,20 @@ public:
       memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) );
       return *this;
     }
-    MacOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ )
+
+    MacOSSurfaceCreateInfoMVK & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    MacOSSurfaceCreateInfoMVK& setFlags( MacOSSurfaceCreateFlagsMVK flags_ )
+    MacOSSurfaceCreateInfoMVK & setFlags( MacOSSurfaceCreateFlagsMVK flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    MacOSSurfaceCreateInfoMVK& setPView( const void* pView_ )
+    MacOSSurfaceCreateInfoMVK & setPView( const void* pView_ )
     {
       pView = pView_;
       return *this;
@@ -15181,12 +32711,12 @@ public:
 
     operator VkMacOSSurfaceCreateInfoMVK const&() const
     {
-      return *reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>(this);
+      return *reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( this );
     }
 
     operator VkMacOSSurfaceCreateInfoMVK &()
     {
-      return *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>(this);
+      return *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>( this );
     }
 
     bool operator==( MacOSSurfaceCreateInfoMVK const& rhs ) const
@@ -15213,374 +32743,1521 @@ public:
   static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
 
-  struct PipelineViewportWScalingStateCreateInfoNV
+  struct MappedMemoryRange
   {
-    PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = 0,
-                                               uint32_t viewportCount_ = 0,
-                                               const ViewportWScalingNV* pViewportWScalings_ = nullptr )
-      : viewportWScalingEnable( viewportWScalingEnable_ )
-      , viewportCount( viewportCount_ )
-      , pViewportWScalings( pViewportWScalings_ )
+    MappedMemoryRange( DeviceMemory memory_ = DeviceMemory(),
+                       DeviceSize offset_ = 0,
+                       DeviceSize size_ = 0 )
+      : memory( memory_ )
+      , offset( offset_ )
+      , size( size_ )
+    {}
+
+    MappedMemoryRange( VkMappedMemoryRange const & rhs )
     {
+      memcpy( this, &rhs, sizeof( MappedMemoryRange ) );
     }
 
-    PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
+    MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs )
     {
-      memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) );
-    }
-
-    PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) );
+      memcpy( this, &rhs, sizeof( MappedMemoryRange ) );
       return *this;
     }
-    PipelineViewportWScalingStateCreateInfoNV& setPNext( const void* pNext_ )
+
+    MappedMemoryRange & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PipelineViewportWScalingStateCreateInfoNV& setViewportWScalingEnable( Bool32 viewportWScalingEnable_ )
+    MappedMemoryRange & setMemory( DeviceMemory memory_ )
     {
-      viewportWScalingEnable = viewportWScalingEnable_;
+      memory = memory_;
       return *this;
     }
 
-    PipelineViewportWScalingStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ )
+    MappedMemoryRange & setOffset( DeviceSize offset_ )
     {
-      viewportCount = viewportCount_;
+      offset = offset_;
       return *this;
     }
 
-    PipelineViewportWScalingStateCreateInfoNV& setPViewportWScalings( const ViewportWScalingNV* pViewportWScalings_ )
+    MappedMemoryRange & setSize( DeviceSize size_ )
     {
-      pViewportWScalings = pViewportWScalings_;
+      size = size_;
       return *this;
     }
 
-    operator VkPipelineViewportWScalingStateCreateInfoNV const&() const
+    operator VkMappedMemoryRange const&() const
     {
-      return *reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(this);
+      return *reinterpret_cast<const VkMappedMemoryRange*>( this );
     }
 
-    operator VkPipelineViewportWScalingStateCreateInfoNV &()
+    operator VkMappedMemoryRange &()
     {
-      return *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(this);
+      return *reinterpret_cast<VkMappedMemoryRange*>( this );
     }
 
-    bool operator==( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const
+    bool operator==( MappedMemoryRange const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( viewportWScalingEnable == rhs.viewportWScalingEnable )
-          && ( viewportCount == rhs.viewportCount )
-          && ( pViewportWScalings == rhs.pViewportWScalings );
+          && ( memory == rhs.memory )
+          && ( offset == rhs.offset )
+          && ( size == rhs.size );
     }
 
-    bool operator!=( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const
+    bool operator!=( MappedMemoryRange const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV;
+    StructureType sType = StructureType::eMappedMemoryRange;
 
   public:
     const void* pNext = nullptr;
-    Bool32 viewportWScalingEnable;
-    uint32_t viewportCount;
-    const ViewportWScalingNV* pViewportWScalings;
+    DeviceMemory memory;
+    DeviceSize offset;
+    DeviceSize size;
   };
-  static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" );
+  static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" );
 
-  struct PhysicalDeviceDiscardRectanglePropertiesEXT
+  struct MemoryAllocateFlagsInfo
   {
-    PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 )
-      : maxDiscardRectangles( maxDiscardRectangles_ )
+    MemoryAllocateFlagsInfo( MemoryAllocateFlags flags_ = MemoryAllocateFlags(),
+                             uint32_t deviceMask_ = 0 )
+      : flags( flags_ )
+      , deviceMask( deviceMask_ )
+    {}
+
+    MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs )
     {
+      memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) );
     }
 
-    PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
+    MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs )
     {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) );
-    }
-
-    PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) );
+      memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) );
       return *this;
     }
-    PhysicalDeviceDiscardRectanglePropertiesEXT& setPNext( void* pNext_ )
+
+    MemoryAllocateFlagsInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PhysicalDeviceDiscardRectanglePropertiesEXT& setMaxDiscardRectangles( uint32_t maxDiscardRectangles_ )
+    MemoryAllocateFlagsInfo & setFlags( MemoryAllocateFlags flags_ )
     {
-      maxDiscardRectangles = maxDiscardRectangles_;
+      flags = flags_;
       return *this;
     }
 
-    operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const&() const
+    MemoryAllocateFlagsInfo & setDeviceMask( uint32_t deviceMask_ )
     {
-      return *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this);
+      deviceMask = deviceMask_;
+      return *this;
     }
 
-    operator VkPhysicalDeviceDiscardRectanglePropertiesEXT &()
+    operator VkMemoryAllocateFlagsInfo const&() const
     {
-      return *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this);
+      return *reinterpret_cast<const VkMemoryAllocateFlagsInfo*>( this );
     }
 
-    bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const
+    operator VkMemoryAllocateFlagsInfo &()
+    {
+      return *reinterpret_cast<VkMemoryAllocateFlagsInfo*>( this );
+    }
+
+    bool operator==( MemoryAllocateFlagsInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( maxDiscardRectangles == rhs.maxDiscardRectangles );
+          && ( flags == rhs.flags )
+          && ( deviceMask == rhs.deviceMask );
     }
 
-    bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const
+    bool operator!=( MemoryAllocateFlagsInfo const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxDiscardRectangles;
-  };
-  static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
-  {
-    operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this);
-    }
-
-    operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this);
-    }
-
-    bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( perViewPositionAllComponents == rhs.perViewPositionAllComponents );
-    }
-
-    bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 perViewPositionAllComponents;
-  };
-  static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceSurfaceInfo2KHR
-  {
-    PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = SurfaceKHR() )
-      : surface( surface_ )
-    {
-    }
-
-    PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) );
-    }
-
-    PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) );
-      return *this;
-    }
-    PhysicalDeviceSurfaceInfo2KHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceSurfaceInfo2KHR& setSurface( SurfaceKHR surface_ )
-    {
-      surface = surface_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceSurfaceInfo2KHR const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>(this);
-    }
-
-    operator VkPhysicalDeviceSurfaceInfo2KHR &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( surface == rhs.surface );
-    }
-
-    bool operator!=( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR;
+    StructureType sType = StructureType::eMemoryAllocateFlagsInfo;
 
   public:
     const void* pNext = nullptr;
-    SurfaceKHR surface;
+    MemoryAllocateFlags flags;
+    uint32_t deviceMask;
   };
-  static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" );
+  static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "struct and wrapper have different size!" );
 
-  struct DisplayPlaneProperties2KHR
+  struct MemoryAllocateInfo
   {
-    operator VkDisplayPlaneProperties2KHR const&() const
+    MemoryAllocateInfo( DeviceSize allocationSize_ = 0,
+                        uint32_t memoryTypeIndex_ = 0 )
+      : allocationSize( allocationSize_ )
+      , memoryTypeIndex( memoryTypeIndex_ )
+    {}
+
+    MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs )
     {
-      return *reinterpret_cast<const VkDisplayPlaneProperties2KHR*>(this);
+      memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) );
     }
 
-    operator VkDisplayPlaneProperties2KHR &()
+    MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs )
     {
-      return *reinterpret_cast<VkDisplayPlaneProperties2KHR*>(this);
-    }
-
-    bool operator==( DisplayPlaneProperties2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( displayPlaneProperties == rhs.displayPlaneProperties );
-    }
-
-    bool operator!=( DisplayPlaneProperties2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDisplayPlaneProperties2KHR;
-
-  public:
-    void* pNext = nullptr;
-    DisplayPlanePropertiesKHR displayPlaneProperties;
-  };
-  static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "struct and wrapper have different size!" );
-
-  struct DisplayModeProperties2KHR
-  {
-    operator VkDisplayModeProperties2KHR const&() const
-    {
-      return *reinterpret_cast<const VkDisplayModeProperties2KHR*>(this);
-    }
-
-    operator VkDisplayModeProperties2KHR &()
-    {
-      return *reinterpret_cast<VkDisplayModeProperties2KHR*>(this);
-    }
-
-    bool operator==( DisplayModeProperties2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( displayModeProperties == rhs.displayModeProperties );
-    }
-
-    bool operator!=( DisplayModeProperties2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDisplayModeProperties2KHR;
-
-  public:
-    void* pNext = nullptr;
-    DisplayModePropertiesKHR displayModeProperties;
-  };
-  static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" );
-
-  struct DisplayPlaneInfo2KHR
-  {
-    DisplayPlaneInfo2KHR( DisplayModeKHR mode_ = DisplayModeKHR(),
-                          uint32_t planeIndex_ = 0 )
-      : mode( mode_ )
-      , planeIndex( planeIndex_ )
-    {
-    }
-
-    DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPlaneInfo2KHR ) );
-    }
-
-    DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPlaneInfo2KHR ) );
+      memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) );
       return *this;
     }
-    DisplayPlaneInfo2KHR& setPNext( const void* pNext_ )
+
+    MemoryAllocateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    DisplayPlaneInfo2KHR& setMode( DisplayModeKHR mode_ )
+    MemoryAllocateInfo & setAllocationSize( DeviceSize allocationSize_ )
     {
-      mode = mode_;
+      allocationSize = allocationSize_;
       return *this;
     }
 
-    DisplayPlaneInfo2KHR& setPlaneIndex( uint32_t planeIndex_ )
+    MemoryAllocateInfo & setMemoryTypeIndex( uint32_t memoryTypeIndex_ )
     {
-      planeIndex = planeIndex_;
+      memoryTypeIndex = memoryTypeIndex_;
       return *this;
     }
 
-    operator VkDisplayPlaneInfo2KHR const&() const
+    operator VkMemoryAllocateInfo const&() const
     {
-      return *reinterpret_cast<const VkDisplayPlaneInfo2KHR*>(this);
+      return *reinterpret_cast<const VkMemoryAllocateInfo*>( this );
     }
 
-    operator VkDisplayPlaneInfo2KHR &()
+    operator VkMemoryAllocateInfo &()
     {
-      return *reinterpret_cast<VkDisplayPlaneInfo2KHR*>(this);
+      return *reinterpret_cast<VkMemoryAllocateInfo*>( this );
     }
 
-    bool operator==( DisplayPlaneInfo2KHR const& rhs ) const
+    bool operator==( MemoryAllocateInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( mode == rhs.mode )
-          && ( planeIndex == rhs.planeIndex );
+          && ( allocationSize == rhs.allocationSize )
+          && ( memoryTypeIndex == rhs.memoryTypeIndex );
     }
 
-    bool operator!=( DisplayPlaneInfo2KHR const& rhs ) const
+    bool operator!=( MemoryAllocateInfo const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eDisplayPlaneInfo2KHR;
+    StructureType sType = StructureType::eMemoryAllocateInfo;
 
   public:
     const void* pNext = nullptr;
-    DisplayModeKHR mode;
-    uint32_t planeIndex;
+    DeviceSize allocationSize;
+    uint32_t memoryTypeIndex;
   };
-  static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" );
+  static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" );
+
+  struct MemoryBarrier
+  {
+    MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(),
+                   AccessFlags dstAccessMask_ = AccessFlags() )
+      : srcAccessMask( srcAccessMask_ )
+      , dstAccessMask( dstAccessMask_ )
+    {}
+
+    MemoryBarrier( VkMemoryBarrier const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( MemoryBarrier ) );
+    }
+
+    MemoryBarrier& operator=( VkMemoryBarrier const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( MemoryBarrier ) );
+      return *this;
+    }
+
+    MemoryBarrier & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    MemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ )
+    {
+      srcAccessMask = srcAccessMask_;
+      return *this;
+    }
+
+    MemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ )
+    {
+      dstAccessMask = dstAccessMask_;
+      return *this;
+    }
+
+    operator VkMemoryBarrier const&() const
+    {
+      return *reinterpret_cast<const VkMemoryBarrier*>( this );
+    }
+
+    operator VkMemoryBarrier &()
+    {
+      return *reinterpret_cast<VkMemoryBarrier*>( this );
+    }
+
+    bool operator==( MemoryBarrier const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( srcAccessMask == rhs.srcAccessMask )
+          && ( dstAccessMask == rhs.dstAccessMask );
+    }
+
+    bool operator!=( MemoryBarrier const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eMemoryBarrier;
+
+  public:
+    const void* pNext = nullptr;
+    AccessFlags srcAccessMask;
+    AccessFlags dstAccessMask;
+  };
+  static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" );
+
+  struct MemoryDedicatedAllocateInfo
+  {
+    MemoryDedicatedAllocateInfo( Image image_ = Image(),
+                                 Buffer buffer_ = Buffer() )
+      : image( image_ )
+      , buffer( buffer_ )
+    {}
+
+    MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfo ) );
+    }
+
+    MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfo ) );
+      return *this;
+    }
+
+    MemoryDedicatedAllocateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    MemoryDedicatedAllocateInfo & setImage( Image image_ )
+    {
+      image = image_;
+      return *this;
+    }
+
+    MemoryDedicatedAllocateInfo & setBuffer( Buffer buffer_ )
+    {
+      buffer = buffer_;
+      return *this;
+    }
+
+    operator VkMemoryDedicatedAllocateInfo const&() const
+    {
+      return *reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>( this );
+    }
+
+    operator VkMemoryDedicatedAllocateInfo &()
+    {
+      return *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>( this );
+    }
+
+    bool operator==( MemoryDedicatedAllocateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( image == rhs.image )
+          && ( buffer == rhs.buffer );
+    }
+
+    bool operator!=( MemoryDedicatedAllocateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eMemoryDedicatedAllocateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    Image image;
+    Buffer buffer;
+  };
+  static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "struct and wrapper have different size!" );
+
+  struct MemoryDedicatedRequirements
+  {
+    operator VkMemoryDedicatedRequirements const&() const
+    {
+      return *reinterpret_cast<const VkMemoryDedicatedRequirements*>( this );
+    }
+
+    operator VkMemoryDedicatedRequirements &()
+    {
+      return *reinterpret_cast<VkMemoryDedicatedRequirements*>( this );
+    }
+
+    bool operator==( MemoryDedicatedRequirements const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation )
+          && ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation );
+    }
+
+    bool operator!=( MemoryDedicatedRequirements const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eMemoryDedicatedRequirements;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 prefersDedicatedAllocation;
+    Bool32 requiresDedicatedAllocation;
+  };
+  static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "struct and wrapper have different size!" );
+
+  struct MemoryFdPropertiesKHR
+  {
+    operator VkMemoryFdPropertiesKHR const&() const
+    {
+      return *reinterpret_cast<const VkMemoryFdPropertiesKHR*>( this );
+    }
+
+    operator VkMemoryFdPropertiesKHR &()
+    {
+      return *reinterpret_cast<VkMemoryFdPropertiesKHR*>( this );
+    }
+
+    bool operator==( MemoryFdPropertiesKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( memoryTypeBits == rhs.memoryTypeBits );
+    }
+
+    bool operator!=( MemoryFdPropertiesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eMemoryFdPropertiesKHR;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t memoryTypeBits;
+  };
+  static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  struct MemoryGetAndroidHardwareBufferInfoANDROID
+  {
+    MemoryGetAndroidHardwareBufferInfoANDROID( DeviceMemory memory_ = DeviceMemory() )
+      : memory( memory_ )
+    {}
+
+    MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) );
+    }
+
+    MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) );
+      return *this;
+    }
+
+    MemoryGetAndroidHardwareBufferInfoANDROID & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    MemoryGetAndroidHardwareBufferInfoANDROID & setMemory( DeviceMemory memory_ )
+    {
+      memory = memory_;
+      return *this;
+    }
+
+    operator VkMemoryGetAndroidHardwareBufferInfoANDROID const&() const
+    {
+      return *reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>( this );
+    }
+
+    operator VkMemoryGetAndroidHardwareBufferInfoANDROID &()
+    {
+      return *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>( this );
+    }
+
+    bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( memory == rhs.memory );
+    }
+
+    bool operator!=( MemoryGetAndroidHardwareBufferInfoANDROID const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID;
+
+  public:
+    const void* pNext = nullptr;
+    DeviceMemory memory;
+  };
+  static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+  struct MemoryGetFdInfoKHR
+  {
+    MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(),
+                        ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+      : memory( memory_ )
+      , handleType( handleType_ )
+    {}
+
+    MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
+    }
+
+    MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
+      return *this;
+    }
+
+    MemoryGetFdInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    MemoryGetFdInfoKHR & setMemory( DeviceMemory memory_ )
+    {
+      memory = memory_;
+      return *this;
+    }
+
+    MemoryGetFdInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    operator VkMemoryGetFdInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkMemoryGetFdInfoKHR*>( this );
+    }
+
+    operator VkMemoryGetFdInfoKHR &()
+    {
+      return *reinterpret_cast<VkMemoryGetFdInfoKHR*>( this );
+    }
+
+    bool operator==( MemoryGetFdInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( memory == rhs.memory )
+          && ( handleType == rhs.handleType );
+    }
+
+    bool operator!=( MemoryGetFdInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eMemoryGetFdInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    DeviceMemory memory;
+    ExternalMemoryHandleTypeFlagBits handleType;
+  };
+  static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct MemoryGetWin32HandleInfoKHR
+  {
+    MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(),
+                                 ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+      : memory( memory_ )
+      , handleType( handleType_ )
+    {}
+
+    MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
+    }
+
+    MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
+      return *this;
+    }
+
+    MemoryGetWin32HandleInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    MemoryGetWin32HandleInfoKHR & setMemory( DeviceMemory memory_ )
+    {
+      memory = memory_;
+      return *this;
+    }
+
+    MemoryGetWin32HandleInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    operator VkMemoryGetWin32HandleInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( this );
+    }
+
+    operator VkMemoryGetWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>( this );
+    }
+
+    bool operator==( MemoryGetWin32HandleInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( memory == rhs.memory )
+          && ( handleType == rhs.handleType );
+    }
+
+    bool operator!=( MemoryGetWin32HandleInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    DeviceMemory memory;
+    ExternalMemoryHandleTypeFlagBits handleType;
+  };
+  static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  struct MemoryHeap
+  {
+    operator VkMemoryHeap const&() const
+    {
+      return *reinterpret_cast<const VkMemoryHeap*>( this );
+    }
+
+    operator VkMemoryHeap &()
+    {
+      return *reinterpret_cast<VkMemoryHeap*>( this );
+    }
+
+    bool operator==( MemoryHeap const& rhs ) const
+    {
+      return ( size == rhs.size )
+          && ( flags == rhs.flags );
+    }
+
+    bool operator!=( MemoryHeap const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    DeviceSize size;
+    MemoryHeapFlags flags;
+  };
+  static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" );
+
+  struct MemoryHostPointerPropertiesEXT
+  {
+    MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 )
+      : memoryTypeBits( memoryTypeBits_ )
+    {}
+
+    MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) );
+    }
+
+    MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) );
+      return *this;
+    }
+
+    MemoryHostPointerPropertiesEXT & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    MemoryHostPointerPropertiesEXT & setMemoryTypeBits( uint32_t memoryTypeBits_ )
+    {
+      memoryTypeBits = memoryTypeBits_;
+      return *this;
+    }
+
+    operator VkMemoryHostPointerPropertiesEXT const&() const
+    {
+      return *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>( this );
+    }
+
+    operator VkMemoryHostPointerPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( this );
+    }
+
+    bool operator==( MemoryHostPointerPropertiesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( memoryTypeBits == rhs.memoryTypeBits );
+    }
+
+    bool operator!=( MemoryHostPointerPropertiesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t memoryTypeBits;
+  };
+  static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" );
+
+  struct MemoryRequirements
+  {
+    operator VkMemoryRequirements const&() const
+    {
+      return *reinterpret_cast<const VkMemoryRequirements*>( this );
+    }
+
+    operator VkMemoryRequirements &()
+    {
+      return *reinterpret_cast<VkMemoryRequirements*>( this );
+    }
+
+    bool operator==( MemoryRequirements const& rhs ) const
+    {
+      return ( size == rhs.size )
+          && ( alignment == rhs.alignment )
+          && ( memoryTypeBits == rhs.memoryTypeBits );
+    }
+
+    bool operator!=( MemoryRequirements const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    DeviceSize size;
+    DeviceSize alignment;
+    uint32_t memoryTypeBits;
+  };
+  static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" );
+
+  struct MemoryRequirements2
+  {
+    operator VkMemoryRequirements2 const&() const
+    {
+      return *reinterpret_cast<const VkMemoryRequirements2*>( this );
+    }
+
+    operator VkMemoryRequirements2 &()
+    {
+      return *reinterpret_cast<VkMemoryRequirements2*>( this );
+    }
+
+    bool operator==( MemoryRequirements2 const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( memoryRequirements == rhs.memoryRequirements );
+    }
+
+    bool operator!=( MemoryRequirements2 const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eMemoryRequirements2;
+
+  public:
+    void* pNext = nullptr;
+    MemoryRequirements memoryRequirements;
+  };
+  static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "struct and wrapper have different size!" );
+
+  struct MemoryType
+  {
+    operator VkMemoryType const&() const
+    {
+      return *reinterpret_cast<const VkMemoryType*>( this );
+    }
+
+    operator VkMemoryType &()
+    {
+      return *reinterpret_cast<VkMemoryType*>( this );
+    }
+
+    bool operator==( MemoryType const& rhs ) const
+    {
+      return ( propertyFlags == rhs.propertyFlags )
+          && ( heapIndex == rhs.heapIndex );
+    }
+
+    bool operator!=( MemoryType const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    MemoryPropertyFlags propertyFlags;
+    uint32_t heapIndex;
+  };
+  static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct MemoryWin32HandlePropertiesKHR
+  {
+    operator VkMemoryWin32HandlePropertiesKHR const&() const
+    {
+      return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>( this );
+    }
+
+    operator VkMemoryWin32HandlePropertiesKHR &()
+    {
+      return *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( this );
+    }
+
+    bool operator==( MemoryWin32HandlePropertiesKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( memoryTypeBits == rhs.memoryTypeBits );
+    }
+
+    bool operator!=( MemoryWin32HandlePropertiesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t memoryTypeBits;
+  };
+  static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  struct MultisamplePropertiesEXT
+  {
+    operator VkMultisamplePropertiesEXT const&() const
+    {
+      return *reinterpret_cast<const VkMultisamplePropertiesEXT*>( this );
+    }
+
+    operator VkMultisamplePropertiesEXT &()
+    {
+      return *reinterpret_cast<VkMultisamplePropertiesEXT*>( this );
+    }
+
+    bool operator==( MultisamplePropertiesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize );
+    }
+
+    bool operator!=( MultisamplePropertiesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eMultisamplePropertiesEXT;
+
+  public:
+    void* pNext = nullptr;
+    Extent2D maxSampleLocationGridSize;
+  };
+  static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" );
+
+  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 )
+      : objectCount( objectCount_ )
+      , pObjectEntryTypes( pObjectEntryTypes_ )
+      , pObjectEntryCounts( pObjectEntryCounts_ )
+      , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
+      , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
+      , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
+      , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
+      , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
+      , maxPipelineLayouts( maxPipelineLayouts_ )
+    {}
+
+    ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
+    }
+
+    ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
+      return *this;
+    }
+
+    ObjectTableCreateInfoNVX & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ObjectTableCreateInfoNVX & setObjectCount( uint32_t objectCount_ )
+    {
+      objectCount = objectCount_;
+      return *this;
+    }
+
+    ObjectTableCreateInfoNVX & setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ )
+    {
+      pObjectEntryTypes = pObjectEntryTypes_;
+      return *this;
+    }
+
+    ObjectTableCreateInfoNVX & setPObjectEntryCounts( const uint32_t* pObjectEntryCounts_ )
+    {
+      pObjectEntryCounts = pObjectEntryCounts_;
+      return *this;
+    }
+
+    ObjectTableCreateInfoNVX & setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ )
+    {
+      pObjectEntryUsageFlags = pObjectEntryUsageFlags_;
+      return *this;
+    }
+
+    ObjectTableCreateInfoNVX & setMaxUniformBuffersPerDescriptor( uint32_t maxUniformBuffersPerDescriptor_ )
+    {
+      maxUniformBuffersPerDescriptor = maxUniformBuffersPerDescriptor_;
+      return *this;
+    }
+
+    ObjectTableCreateInfoNVX & setMaxStorageBuffersPerDescriptor( uint32_t maxStorageBuffersPerDescriptor_ )
+    {
+      maxStorageBuffersPerDescriptor = maxStorageBuffersPerDescriptor_;
+      return *this;
+    }
+
+    ObjectTableCreateInfoNVX & setMaxStorageImagesPerDescriptor( uint32_t maxStorageImagesPerDescriptor_ )
+    {
+      maxStorageImagesPerDescriptor = maxStorageImagesPerDescriptor_;
+      return *this;
+    }
+
+    ObjectTableCreateInfoNVX & setMaxSampledImagesPerDescriptor( uint32_t maxSampledImagesPerDescriptor_ )
+    {
+      maxSampledImagesPerDescriptor = maxSampledImagesPerDescriptor_;
+      return *this;
+    }
+
+    ObjectTableCreateInfoNVX & setMaxPipelineLayouts( uint32_t maxPipelineLayouts_ )
+    {
+      maxPipelineLayouts = maxPipelineLayouts_;
+      return *this;
+    }
+
+    operator VkObjectTableCreateInfoNVX const&() const
+    {
+      return *reinterpret_cast<const VkObjectTableCreateInfoNVX*>( this );
+    }
+
+    operator VkObjectTableCreateInfoNVX &()
+    {
+      return *reinterpret_cast<VkObjectTableCreateInfoNVX*>( this );
+    }
+
+    bool operator==( ObjectTableCreateInfoNVX const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( objectCount == rhs.objectCount )
+          && ( pObjectEntryTypes == rhs.pObjectEntryTypes )
+          && ( pObjectEntryCounts == rhs.pObjectEntryCounts )
+          && ( pObjectEntryUsageFlags == rhs.pObjectEntryUsageFlags )
+          && ( maxUniformBuffersPerDescriptor == rhs.maxUniformBuffersPerDescriptor )
+          && ( maxStorageBuffersPerDescriptor == rhs.maxStorageBuffersPerDescriptor )
+          && ( maxStorageImagesPerDescriptor == rhs.maxStorageImagesPerDescriptor )
+          && ( maxSampledImagesPerDescriptor == rhs.maxSampledImagesPerDescriptor )
+          && ( maxPipelineLayouts == rhs.maxPipelineLayouts );
+    }
+
+    bool operator!=( ObjectTableCreateInfoNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eObjectTableCreateInfoNVX;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t objectCount;
+    const ObjectEntryTypeNVX* pObjectEntryTypes;
+    const uint32_t* pObjectEntryCounts;
+    const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
+    uint32_t maxUniformBuffersPerDescriptor;
+    uint32_t maxStorageBuffersPerDescriptor;
+    uint32_t maxStorageImagesPerDescriptor;
+    uint32_t maxSampledImagesPerDescriptor;
+    uint32_t maxPipelineLayouts;
+  };
+  static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" );
+
+  struct ObjectTableEntryNVX
+  {
+    ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
+                         ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() )
+      : type( type_ )
+      , flags( flags_ )
+    {}
+
+    ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
+    }
+
+    ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
+      return *this;
+    }
+
+    ObjectTableEntryNVX & setType( ObjectEntryTypeNVX type_ )
+    {
+      type = type_;
+      return *this;
+    }
+
+    ObjectTableEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    operator VkObjectTableEntryNVX const&() const
+    {
+      return *reinterpret_cast<const VkObjectTableEntryNVX*>( this );
+    }
+
+    operator VkObjectTableEntryNVX &()
+    {
+      return *reinterpret_cast<VkObjectTableEntryNVX*>( this );
+    }
+
+    bool operator==( ObjectTableEntryNVX const& rhs ) const
+    {
+      return ( type == rhs.type )
+          && ( flags == rhs.flags );
+    }
+
+    bool operator!=( ObjectTableEntryNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ObjectEntryTypeNVX type;
+    ObjectEntryUsageFlagsNVX flags;
+  };
+  static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" );
+
+  struct ObjectTableDescriptorSetEntryNVX
+  {
+    ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
+                                      ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
+                                      PipelineLayout pipelineLayout_ = PipelineLayout(),
+                                      DescriptorSet descriptorSet_ = DescriptorSet() )
+      : type( type_ )
+      , flags( flags_ )
+      , pipelineLayout( pipelineLayout_ )
+      , descriptorSet( descriptorSet_ )
+    {}
+
+    explicit ObjectTableDescriptorSetEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
+                                               PipelineLayout pipelineLayout_ = PipelineLayout(),
+                                               DescriptorSet descriptorSet_ = DescriptorSet() )
+      : type( objectTableEntryNVX.type )
+      , flags( objectTableEntryNVX.flags )
+      , pipelineLayout( pipelineLayout_ )
+      , descriptorSet( descriptorSet_ )
+    {}
+
+    ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
+    }
+
+    ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
+      return *this;
+    }
+
+    ObjectTableDescriptorSetEntryNVX & setType( ObjectEntryTypeNVX type_ )
+    {
+      type = type_;
+      return *this;
+    }
+
+    ObjectTableDescriptorSetEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ObjectTableDescriptorSetEntryNVX & setPipelineLayout( PipelineLayout pipelineLayout_ )
+    {
+      pipelineLayout = pipelineLayout_;
+      return *this;
+    }
+
+    ObjectTableDescriptorSetEntryNVX & setDescriptorSet( DescriptorSet descriptorSet_ )
+    {
+      descriptorSet = descriptorSet_;
+      return *this;
+    }
+
+    operator VkObjectTableDescriptorSetEntryNVX const&() const
+    {
+      return *reinterpret_cast<const VkObjectTableDescriptorSetEntryNVX*>( this );
+    }
+
+    operator VkObjectTableDescriptorSetEntryNVX &()
+    {
+      return *reinterpret_cast<VkObjectTableDescriptorSetEntryNVX*>( this );
+    }
+
+    bool operator==( ObjectTableDescriptorSetEntryNVX const& rhs ) const
+    {
+      return ( type == rhs.type )
+          && ( flags == rhs.flags )
+          && ( pipelineLayout == rhs.pipelineLayout )
+          && ( descriptorSet == rhs.descriptorSet );
+    }
+
+    bool operator!=( ObjectTableDescriptorSetEntryNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ObjectEntryTypeNVX type;
+    ObjectEntryUsageFlagsNVX flags;
+    PipelineLayout pipelineLayout;
+    DescriptorSet descriptorSet;
+  };
+  static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" );
+
+  struct ObjectTableIndexBufferEntryNVX
+  {
+    ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
+                                    ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
+                                    Buffer buffer_ = Buffer(),
+                                    IndexType indexType_ = IndexType::eUint16 )
+      : type( type_ )
+      , flags( flags_ )
+      , buffer( buffer_ )
+      , indexType( indexType_ )
+    {}
+
+    explicit ObjectTableIndexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
+                                             Buffer buffer_ = Buffer(),
+                                             IndexType indexType_ = IndexType::eUint16 )
+      : type( objectTableEntryNVX.type )
+      , flags( objectTableEntryNVX.flags )
+      , buffer( buffer_ )
+      , indexType( indexType_ )
+    {}
+
+    ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
+    }
+
+    ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
+      return *this;
+    }
+
+    ObjectTableIndexBufferEntryNVX & setType( ObjectEntryTypeNVX type_ )
+    {
+      type = type_;
+      return *this;
+    }
+
+    ObjectTableIndexBufferEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ObjectTableIndexBufferEntryNVX & setBuffer( Buffer buffer_ )
+    {
+      buffer = buffer_;
+      return *this;
+    }
+
+    ObjectTableIndexBufferEntryNVX & setIndexType( IndexType indexType_ )
+    {
+      indexType = indexType_;
+      return *this;
+    }
+
+    operator VkObjectTableIndexBufferEntryNVX const&() const
+    {
+      return *reinterpret_cast<const VkObjectTableIndexBufferEntryNVX*>( this );
+    }
+
+    operator VkObjectTableIndexBufferEntryNVX &()
+    {
+      return *reinterpret_cast<VkObjectTableIndexBufferEntryNVX*>( this );
+    }
+
+    bool operator==( ObjectTableIndexBufferEntryNVX const& rhs ) const
+    {
+      return ( type == rhs.type )
+          && ( flags == rhs.flags )
+          && ( buffer == rhs.buffer )
+          && ( indexType == rhs.indexType );
+    }
+
+    bool operator!=( ObjectTableIndexBufferEntryNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ObjectEntryTypeNVX type;
+    ObjectEntryUsageFlagsNVX flags;
+    Buffer buffer;
+    IndexType indexType;
+  };
+  static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" );
+
+  struct ObjectTablePipelineEntryNVX
+  {
+    ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
+                                 ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
+                                 Pipeline pipeline_ = Pipeline() )
+      : type( type_ )
+      , flags( flags_ )
+      , pipeline( pipeline_ )
+    {}
+
+    explicit ObjectTablePipelineEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
+                                          Pipeline pipeline_ = Pipeline() )
+      : type( objectTableEntryNVX.type )
+      , flags( objectTableEntryNVX.flags )
+      , pipeline( pipeline_ )
+    {}
+
+    ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
+    }
+
+    ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
+      return *this;
+    }
+
+    ObjectTablePipelineEntryNVX & setType( ObjectEntryTypeNVX type_ )
+    {
+      type = type_;
+      return *this;
+    }
+
+    ObjectTablePipelineEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ObjectTablePipelineEntryNVX & setPipeline( Pipeline pipeline_ )
+    {
+      pipeline = pipeline_;
+      return *this;
+    }
+
+    operator VkObjectTablePipelineEntryNVX const&() const
+    {
+      return *reinterpret_cast<const VkObjectTablePipelineEntryNVX*>( this );
+    }
+
+    operator VkObjectTablePipelineEntryNVX &()
+    {
+      return *reinterpret_cast<VkObjectTablePipelineEntryNVX*>( this );
+    }
+
+    bool operator==( ObjectTablePipelineEntryNVX const& rhs ) const
+    {
+      return ( type == rhs.type )
+          && ( flags == rhs.flags )
+          && ( pipeline == rhs.pipeline );
+    }
+
+    bool operator!=( ObjectTablePipelineEntryNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ObjectEntryTypeNVX type;
+    ObjectEntryUsageFlagsNVX flags;
+    Pipeline pipeline;
+  };
+  static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" );
+
+  struct ObjectTablePushConstantEntryNVX
+  {
+    ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
+                                     ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
+                                     PipelineLayout pipelineLayout_ = PipelineLayout(),
+                                     ShaderStageFlags stageFlags_ = ShaderStageFlags() )
+      : type( type_ )
+      , flags( flags_ )
+      , pipelineLayout( pipelineLayout_ )
+      , stageFlags( stageFlags_ )
+    {}
+
+    explicit ObjectTablePushConstantEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
+                                              PipelineLayout pipelineLayout_ = PipelineLayout(),
+                                              ShaderStageFlags stageFlags_ = ShaderStageFlags() )
+      : type( objectTableEntryNVX.type )
+      , flags( objectTableEntryNVX.flags )
+      , pipelineLayout( pipelineLayout_ )
+      , stageFlags( stageFlags_ )
+    {}
+
+    ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
+    }
+
+    ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
+      return *this;
+    }
+
+    ObjectTablePushConstantEntryNVX & setType( ObjectEntryTypeNVX type_ )
+    {
+      type = type_;
+      return *this;
+    }
+
+    ObjectTablePushConstantEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ObjectTablePushConstantEntryNVX & setPipelineLayout( PipelineLayout pipelineLayout_ )
+    {
+      pipelineLayout = pipelineLayout_;
+      return *this;
+    }
+
+    ObjectTablePushConstantEntryNVX & setStageFlags( ShaderStageFlags stageFlags_ )
+    {
+      stageFlags = stageFlags_;
+      return *this;
+    }
+
+    operator VkObjectTablePushConstantEntryNVX const&() const
+    {
+      return *reinterpret_cast<const VkObjectTablePushConstantEntryNVX*>( this );
+    }
+
+    operator VkObjectTablePushConstantEntryNVX &()
+    {
+      return *reinterpret_cast<VkObjectTablePushConstantEntryNVX*>( this );
+    }
+
+    bool operator==( ObjectTablePushConstantEntryNVX const& rhs ) const
+    {
+      return ( type == rhs.type )
+          && ( flags == rhs.flags )
+          && ( pipelineLayout == rhs.pipelineLayout )
+          && ( stageFlags == rhs.stageFlags );
+    }
+
+    bool operator!=( ObjectTablePushConstantEntryNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ObjectEntryTypeNVX type;
+    ObjectEntryUsageFlagsNVX flags;
+    PipelineLayout pipelineLayout;
+    ShaderStageFlags stageFlags;
+  };
+  static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" );
+
+  struct ObjectTableVertexBufferEntryNVX
+  {
+    ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
+                                     ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
+                                     Buffer buffer_ = Buffer() )
+      : type( type_ )
+      , flags( flags_ )
+      , buffer( buffer_ )
+    {}
+
+    explicit ObjectTableVertexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
+                                              Buffer buffer_ = Buffer() )
+      : type( objectTableEntryNVX.type )
+      , flags( objectTableEntryNVX.flags )
+      , buffer( buffer_ )
+    {}
+
+    ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
+    }
+
+    ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
+      return *this;
+    }
+
+    ObjectTableVertexBufferEntryNVX & setType( ObjectEntryTypeNVX type_ )
+    {
+      type = type_;
+      return *this;
+    }
+
+    ObjectTableVertexBufferEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ObjectTableVertexBufferEntryNVX & setBuffer( Buffer buffer_ )
+    {
+      buffer = buffer_;
+      return *this;
+    }
+
+    operator VkObjectTableVertexBufferEntryNVX const&() const
+    {
+      return *reinterpret_cast<const VkObjectTableVertexBufferEntryNVX*>( this );
+    }
+
+    operator VkObjectTableVertexBufferEntryNVX &()
+    {
+      return *reinterpret_cast<VkObjectTableVertexBufferEntryNVX*>( this );
+    }
+
+    bool operator==( ObjectTableVertexBufferEntryNVX const& rhs ) const
+    {
+      return ( type == rhs.type )
+          && ( flags == rhs.flags )
+          && ( buffer == rhs.buffer );
+    }
+
+    bool operator!=( ObjectTableVertexBufferEntryNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ObjectEntryTypeNVX type;
+    ObjectEntryUsageFlagsNVX flags;
+    Buffer buffer;
+  };
+  static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" );
+
+  struct PastPresentationTimingGOOGLE
+  {
+    operator VkPastPresentationTimingGOOGLE const&() const
+    {
+      return *reinterpret_cast<const VkPastPresentationTimingGOOGLE*>( this );
+    }
+
+    operator VkPastPresentationTimingGOOGLE &()
+    {
+      return *reinterpret_cast<VkPastPresentationTimingGOOGLE*>( this );
+    }
+
+    bool operator==( PastPresentationTimingGOOGLE const& rhs ) const
+    {
+      return ( presentID == rhs.presentID )
+          && ( desiredPresentTime == rhs.desiredPresentTime )
+          && ( actualPresentTime == rhs.actualPresentTime )
+          && ( earliestPresentTime == rhs.earliestPresentTime )
+          && ( presentMargin == rhs.presentMargin );
+    }
+
+    bool operator!=( PastPresentationTimingGOOGLE const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t presentID;
+    uint64_t desiredPresentTime;
+    uint64_t actualPresentTime;
+    uint64_t earliestPresentTime;
+    uint64_t presentMargin;
+  };
+  static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" );
 
   struct PhysicalDevice16BitStorageFeatures
   {
@@ -15592,8 +34269,7 @@ public:
       , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ )
       , storagePushConstant16( storagePushConstant16_ )
       , storageInputOutput16( storageInputOutput16_ )
-    {
-    }
+    {}
 
     PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs )
     {
@@ -15605,31 +34281,32 @@ public:
       memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeatures ) );
       return *this;
     }
-    PhysicalDevice16BitStorageFeatures& setPNext( void* pNext_ )
+
+    PhysicalDevice16BitStorageFeatures & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PhysicalDevice16BitStorageFeatures& setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ )
+    PhysicalDevice16BitStorageFeatures & setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ )
     {
       storageBuffer16BitAccess = storageBuffer16BitAccess_;
       return *this;
     }
 
-    PhysicalDevice16BitStorageFeatures& setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ )
+    PhysicalDevice16BitStorageFeatures & setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ )
     {
       uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_;
       return *this;
     }
 
-    PhysicalDevice16BitStorageFeatures& setStoragePushConstant16( Bool32 storagePushConstant16_ )
+    PhysicalDevice16BitStorageFeatures & setStoragePushConstant16( Bool32 storagePushConstant16_ )
     {
       storagePushConstant16 = storagePushConstant16_;
       return *this;
     }
 
-    PhysicalDevice16BitStorageFeatures& setStorageInputOutput16( Bool32 storageInputOutput16_ )
+    PhysicalDevice16BitStorageFeatures & setStorageInputOutput16( Bool32 storageInputOutput16_ )
     {
       storageInputOutput16 = storageInputOutput16_;
       return *this;
@@ -15637,12 +34314,12 @@ public:
 
     operator VkPhysicalDevice16BitStorageFeatures const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(this);
+      return *reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>( this );
     }
 
     operator VkPhysicalDevice16BitStorageFeatures &()
     {
-      return *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(this);
+      return *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>( this );
     }
 
     bool operator==( PhysicalDevice16BitStorageFeatures const& rhs ) const
@@ -15672,864 +34349,151 @@ public:
   };
   static_assert( sizeof( PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), "struct and wrapper have different size!" );
 
-  using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
-
-  struct BufferMemoryRequirementsInfo2
+  struct PhysicalDevice8BitStorageFeaturesKHR
   {
-    BufferMemoryRequirementsInfo2( Buffer buffer_ = Buffer() )
-      : buffer( buffer_ )
+    PhysicalDevice8BitStorageFeaturesKHR( Bool32 storageBuffer8BitAccess_ = 0,
+                                          Bool32 uniformAndStorageBuffer8BitAccess_ = 0,
+                                          Bool32 storagePushConstant8_ = 0 )
+      : storageBuffer8BitAccess( storageBuffer8BitAccess_ )
+      , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ )
+      , storagePushConstant8( storagePushConstant8_ )
+    {}
+
+    PhysicalDevice8BitStorageFeaturesKHR( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDevice8BitStorageFeaturesKHR ) );
     }
 
-    BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs )
+    PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs )
     {
-      memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2 ) );
-    }
-
-    BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2 ) );
+      memcpy( this, &rhs, sizeof( PhysicalDevice8BitStorageFeaturesKHR ) );
       return *this;
     }
-    BufferMemoryRequirementsInfo2& setPNext( const void* pNext_ )
+
+    PhysicalDevice8BitStorageFeaturesKHR & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    BufferMemoryRequirementsInfo2& setBuffer( Buffer buffer_ )
+    PhysicalDevice8BitStorageFeaturesKHR & setStorageBuffer8BitAccess( Bool32 storageBuffer8BitAccess_ )
     {
-      buffer = buffer_;
+      storageBuffer8BitAccess = storageBuffer8BitAccess_;
       return *this;
     }
 
-    operator VkBufferMemoryRequirementsInfo2 const&() const
+    PhysicalDevice8BitStorageFeaturesKHR & setUniformAndStorageBuffer8BitAccess( Bool32 uniformAndStorageBuffer8BitAccess_ )
     {
-      return *reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>(this);
+      uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_;
+      return *this;
     }
 
-    operator VkBufferMemoryRequirementsInfo2 &()
+    PhysicalDevice8BitStorageFeaturesKHR & setStoragePushConstant8( Bool32 storagePushConstant8_ )
     {
-      return *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>(this);
+      storagePushConstant8 = storagePushConstant8_;
+      return *this;
     }
 
-    bool operator==( BufferMemoryRequirementsInfo2 const& rhs ) const
+    operator VkPhysicalDevice8BitStorageFeaturesKHR const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDevice8BitStorageFeaturesKHR*>( this );
+    }
+
+    operator VkPhysicalDevice8BitStorageFeaturesKHR &()
+    {
+      return *reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>( this );
+    }
+
+    bool operator==( PhysicalDevice8BitStorageFeaturesKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( buffer == rhs.buffer );
+          && ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess )
+          && ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess )
+          && ( storagePushConstant8 == rhs.storagePushConstant8 );
     }
 
-    bool operator!=( BufferMemoryRequirementsInfo2 const& rhs ) const
+    bool operator!=( PhysicalDevice8BitStorageFeaturesKHR const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eBufferMemoryRequirementsInfo2;
-
-  public:
-    const void* pNext = nullptr;
-    Buffer buffer;
-  };
-  static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
-
-  using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
-
-  struct ImageMemoryRequirementsInfo2
-  {
-    ImageMemoryRequirementsInfo2( Image image_ = Image() )
-      : image( image_ )
-    {
-    }
-
-    ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2 ) );
-    }
-
-    ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2 ) );
-      return *this;
-    }
-    ImageMemoryRequirementsInfo2& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageMemoryRequirementsInfo2& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    operator VkImageMemoryRequirementsInfo2 const&() const
-    {
-      return *reinterpret_cast<const VkImageMemoryRequirementsInfo2*>(this);
-    }
-
-    operator VkImageMemoryRequirementsInfo2 &()
-    {
-      return *reinterpret_cast<VkImageMemoryRequirementsInfo2*>(this);
-    }
-
-    bool operator==( ImageMemoryRequirementsInfo2 const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( image == rhs.image );
-    }
-
-    bool operator!=( ImageMemoryRequirementsInfo2 const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageMemoryRequirementsInfo2;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
-  };
-  static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
-
-  using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
-
-  struct ImageSparseMemoryRequirementsInfo2
-  {
-    ImageSparseMemoryRequirementsInfo2( Image image_ = Image() )
-      : image( image_ )
-    {
-    }
-
-    ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2 ) );
-    }
-
-    ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2 ) );
-      return *this;
-    }
-    ImageSparseMemoryRequirementsInfo2& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageSparseMemoryRequirementsInfo2& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    operator VkImageSparseMemoryRequirementsInfo2 const&() const
-    {
-      return *reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>(this);
-    }
-
-    operator VkImageSparseMemoryRequirementsInfo2 &()
-    {
-      return *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>(this);
-    }
-
-    bool operator==( ImageSparseMemoryRequirementsInfo2 const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( image == rhs.image );
-    }
-
-    bool operator!=( ImageSparseMemoryRequirementsInfo2 const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
-  };
-  static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
-
-  using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
-
-  struct MemoryRequirements2
-  {
-    operator VkMemoryRequirements2 const&() const
-    {
-      return *reinterpret_cast<const VkMemoryRequirements2*>(this);
-    }
-
-    operator VkMemoryRequirements2 &()
-    {
-      return *reinterpret_cast<VkMemoryRequirements2*>(this);
-    }
-
-    bool operator==( MemoryRequirements2 const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memoryRequirements == rhs.memoryRequirements );
-    }
-
-    bool operator!=( MemoryRequirements2 const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryRequirements2;
+    StructureType sType = StructureType::ePhysicalDevice8BitStorageFeaturesKHR;
 
   public:
     void* pNext = nullptr;
-    MemoryRequirements memoryRequirements;
+    Bool32 storageBuffer8BitAccess;
+    Bool32 uniformAndStorageBuffer8BitAccess;
+    Bool32 storagePushConstant8;
   };
-  static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDevice8BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice8BitStorageFeaturesKHR ), "struct and wrapper have different size!" );
 
-  using MemoryRequirements2KHR = MemoryRequirements2;
-
-  struct MemoryDedicatedRequirements
+  struct PhysicalDeviceASTCDecodeFeaturesEXT
   {
-    operator VkMemoryDedicatedRequirements const&() const
+    PhysicalDeviceASTCDecodeFeaturesEXT( Bool32 decodeModeSharedExponent_ = 0 )
+      : decodeModeSharedExponent( decodeModeSharedExponent_ )
+    {}
+
+    PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
     {
-      return *reinterpret_cast<const VkMemoryDedicatedRequirements*>(this);
+      memcpy( this, &rhs, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) );
     }
 
-    operator VkMemoryDedicatedRequirements &()
+    PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
     {
-      return *reinterpret_cast<VkMemoryDedicatedRequirements*>(this);
-    }
-
-    bool operator==( MemoryDedicatedRequirements const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation )
-          && ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation );
-    }
-
-    bool operator!=( MemoryDedicatedRequirements const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryDedicatedRequirements;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 prefersDedicatedAllocation;
-    Bool32 requiresDedicatedAllocation;
-  };
-  static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "struct and wrapper have different size!" );
-
-  using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
-
-  struct MemoryDedicatedAllocateInfo
-  {
-    MemoryDedicatedAllocateInfo( Image image_ = Image(),
-                                 Buffer buffer_ = Buffer() )
-      : image( image_ )
-      , buffer( buffer_ )
-    {
-    }
-
-    MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfo ) );
-    }
-
-    MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfo ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) );
       return *this;
     }
-    MemoryDedicatedAllocateInfo& setPNext( const void* pNext_ )
+
+    PhysicalDeviceASTCDecodeFeaturesEXT & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    MemoryDedicatedAllocateInfo& setImage( Image image_ )
+    PhysicalDeviceASTCDecodeFeaturesEXT & setDecodeModeSharedExponent( Bool32 decodeModeSharedExponent_ )
     {
-      image = image_;
+      decodeModeSharedExponent = decodeModeSharedExponent_;
       return *this;
     }
 
-    MemoryDedicatedAllocateInfo& setBuffer( Buffer buffer_ )
+    operator VkPhysicalDeviceASTCDecodeFeaturesEXT const&() const
     {
-      buffer = buffer_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>( this );
     }
 
-    operator VkMemoryDedicatedAllocateInfo const&() const
+    operator VkPhysicalDeviceASTCDecodeFeaturesEXT &()
     {
-      return *reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>( this );
     }
 
-    operator VkMemoryDedicatedAllocateInfo &()
-    {
-      return *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(this);
-    }
-
-    bool operator==( MemoryDedicatedAllocateInfo const& rhs ) const
+    bool operator==( PhysicalDeviceASTCDecodeFeaturesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( image == rhs.image )
-          && ( buffer == rhs.buffer );
+          && ( decodeModeSharedExponent == rhs.decodeModeSharedExponent );
     }
 
-    bool operator!=( MemoryDedicatedAllocateInfo const& rhs ) const
+    bool operator!=( PhysicalDeviceASTCDecodeFeaturesEXT const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eMemoryDedicatedAllocateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
-    Buffer buffer;
-  };
-  static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "struct and wrapper have different size!" );
-
-  using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
-
-  struct SamplerYcbcrConversionInfo
-  {
-    SamplerYcbcrConversionInfo( SamplerYcbcrConversion conversion_ = SamplerYcbcrConversion() )
-      : conversion( conversion_ )
-    {
-    }
-
-    SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfo ) );
-    }
-
-    SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfo ) );
-      return *this;
-    }
-    SamplerYcbcrConversionInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SamplerYcbcrConversionInfo& setConversion( SamplerYcbcrConversion conversion_ )
-    {
-      conversion = conversion_;
-      return *this;
-    }
-
-    operator VkSamplerYcbcrConversionInfo const&() const
-    {
-      return *reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(this);
-    }
-
-    operator VkSamplerYcbcrConversionInfo &()
-    {
-      return *reinterpret_cast<VkSamplerYcbcrConversionInfo*>(this);
-    }
-
-    bool operator==( SamplerYcbcrConversionInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( conversion == rhs.conversion );
-    }
-
-    bool operator!=( SamplerYcbcrConversionInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSamplerYcbcrConversionInfo;
-
-  public:
-    const void* pNext = nullptr;
-    SamplerYcbcrConversion conversion;
-  };
-  static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "struct and wrapper have different size!" );
-
-  using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
-
-  struct PhysicalDeviceSamplerYcbcrConversionFeatures
-  {
-    PhysicalDeviceSamplerYcbcrConversionFeatures( Bool32 samplerYcbcrConversion_ = 0 )
-      : samplerYcbcrConversion( samplerYcbcrConversion_ )
-    {
-    }
-
-    PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) );
-    }
-
-    PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) );
-      return *this;
-    }
-    PhysicalDeviceSamplerYcbcrConversionFeatures& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceSamplerYcbcrConversionFeatures& setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ )
-    {
-      samplerYcbcrConversion = samplerYcbcrConversion_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this);
-    }
-
-    operator VkPhysicalDeviceSamplerYcbcrConversionFeatures &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this);
-    }
-
-    bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( samplerYcbcrConversion == rhs.samplerYcbcrConversion );
-    }
-
-    bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeatures const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures;
+    StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT;
 
   public:
     void* pNext = nullptr;
-    Bool32 samplerYcbcrConversion;
+    Bool32 decodeModeSharedExponent;
   };
-  static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "struct and wrapper have different size!" );
-
-  using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
-
-  struct SamplerYcbcrConversionImageFormatProperties
-  {
-    operator VkSamplerYcbcrConversionImageFormatProperties const&() const
-    {
-      return *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(this);
-    }
-
-    operator VkSamplerYcbcrConversionImageFormatProperties &()
-    {
-      return *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(this);
-    }
-
-    bool operator==( SamplerYcbcrConversionImageFormatProperties const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount );
-    }
-
-    bool operator!=( SamplerYcbcrConversionImageFormatProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t combinedImageSamplerDescriptorCount;
-  };
-  static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "struct and wrapper have different size!" );
-
-  using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
-
-  struct TextureLODGatherFormatPropertiesAMD
-  {
-    operator VkTextureLODGatherFormatPropertiesAMD const&() const
-    {
-      return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(this);
-    }
-
-    operator VkTextureLODGatherFormatPropertiesAMD &()
-    {
-      return *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(this);
-    }
-
-    bool operator==( TextureLODGatherFormatPropertiesAMD const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD );
-    }
-
-    bool operator!=( TextureLODGatherFormatPropertiesAMD const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 supportsTextureGatherLODBiasAMD;
-  };
-  static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" );
-
-  struct ProtectedSubmitInfo
-  {
-    ProtectedSubmitInfo( Bool32 protectedSubmit_ = 0 )
-      : protectedSubmit( protectedSubmit_ )
-    {
-    }
-
-    ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ProtectedSubmitInfo ) );
-    }
-
-    ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ProtectedSubmitInfo ) );
-      return *this;
-    }
-    ProtectedSubmitInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ProtectedSubmitInfo& setProtectedSubmit( Bool32 protectedSubmit_ )
-    {
-      protectedSubmit = protectedSubmit_;
-      return *this;
-    }
-
-    operator VkProtectedSubmitInfo const&() const
-    {
-      return *reinterpret_cast<const VkProtectedSubmitInfo*>(this);
-    }
-
-    operator VkProtectedSubmitInfo &()
-    {
-      return *reinterpret_cast<VkProtectedSubmitInfo*>(this);
-    }
-
-    bool operator==( ProtectedSubmitInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( protectedSubmit == rhs.protectedSubmit );
-    }
-
-    bool operator!=( ProtectedSubmitInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eProtectedSubmitInfo;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 protectedSubmit;
-  };
-  static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceProtectedMemoryFeatures
-  {
-    PhysicalDeviceProtectedMemoryFeatures( Bool32 protectedMemory_ = 0 )
-      : protectedMemory( protectedMemory_ )
-    {
-    }
-
-    PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryFeatures ) );
-    }
-
-    PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryFeatures ) );
-      return *this;
-    }
-    PhysicalDeviceProtectedMemoryFeatures& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceProtectedMemoryFeatures& setProtectedMemory( Bool32 protectedMemory_ )
-    {
-      protectedMemory = protectedMemory_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceProtectedMemoryFeatures const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(this);
-    }
-
-    operator VkPhysicalDeviceProtectedMemoryFeatures &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(this);
-    }
-
-    bool operator==( PhysicalDeviceProtectedMemoryFeatures const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( protectedMemory == rhs.protectedMemory );
-    }
-
-    bool operator!=( PhysicalDeviceProtectedMemoryFeatures const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 protectedMemory;
-  };
-  static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceProtectedMemoryProperties
-  {
-    PhysicalDeviceProtectedMemoryProperties( Bool32 protectedNoFault_ = 0 )
-      : protectedNoFault( protectedNoFault_ )
-    {
-    }
-
-    PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryProperties ) );
-    }
-
-    PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryProperties ) );
-      return *this;
-    }
-    PhysicalDeviceProtectedMemoryProperties& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceProtectedMemoryProperties& setProtectedNoFault( Bool32 protectedNoFault_ )
-    {
-      protectedNoFault = protectedNoFault_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceProtectedMemoryProperties const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(this);
-    }
-
-    operator VkPhysicalDeviceProtectedMemoryProperties &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(this);
-    }
-
-    bool operator==( PhysicalDeviceProtectedMemoryProperties const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( protectedNoFault == rhs.protectedNoFault );
-    }
-
-    bool operator!=( PhysicalDeviceProtectedMemoryProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 protectedNoFault;
-  };
-  static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "struct and wrapper have different size!" );
-
-  struct PipelineCoverageToColorStateCreateInfoNV
-  {
-    PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(),
-                                              Bool32 coverageToColorEnable_ = 0,
-                                              uint32_t coverageToColorLocation_ = 0 )
-      : flags( flags_ )
-      , coverageToColorEnable( coverageToColorEnable_ )
-      , coverageToColorLocation( coverageToColorLocation_ )
-    {
-    }
-
-    PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) );
-    }
-
-    PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) );
-      return *this;
-    }
-    PipelineCoverageToColorStateCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineCoverageToColorStateCreateInfoNV& setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorEnable( Bool32 coverageToColorEnable_ )
-    {
-      coverageToColorEnable = coverageToColorEnable_;
-      return *this;
-    }
-
-    PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorLocation( uint32_t coverageToColorLocation_ )
-    {
-      coverageToColorLocation = coverageToColorLocation_;
-      return *this;
-    }
-
-    operator VkPipelineCoverageToColorStateCreateInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(this);
-    }
-
-    operator VkPipelineCoverageToColorStateCreateInfoNV &()
-    {
-      return *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(this);
-    }
-
-    bool operator==( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( coverageToColorEnable == rhs.coverageToColorEnable )
-          && ( coverageToColorLocation == rhs.coverageToColorLocation );
-    }
-
-    bool operator!=( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCoverageToColorStateCreateFlagsNV flags;
-    Bool32 coverageToColorEnable;
-    uint32_t coverageToColorLocation;
-  };
-  static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
-  {
-    operator VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this);
-    }
-
-    operator VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats )
-          && ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping );
-    }
-
-    bool operator!=( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 filterMinmaxSingleComponentFormats;
-    Bool32 filterMinmaxImageComponentMapping;
-  };
-  static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" );
-
-  struct MultisamplePropertiesEXT
-  {
-    operator VkMultisamplePropertiesEXT const&() const
-    {
-      return *reinterpret_cast<const VkMultisamplePropertiesEXT*>(this);
-    }
-
-    operator VkMultisamplePropertiesEXT &()
-    {
-      return *reinterpret_cast<VkMultisamplePropertiesEXT*>(this);
-    }
-
-    bool operator==( MultisamplePropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize );
-    }
-
-    bool operator!=( MultisamplePropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMultisamplePropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Extent2D maxSampleLocationGridSize;
-  };
-  static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "struct and wrapper have different size!" );
 
   struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
   {
     PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 )
       : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
-    {
-    }
+    {}
 
     PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs )
     {
@@ -16541,13 +34505,14 @@ public:
       memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) );
       return *this;
     }
-    PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setPNext( void* pNext_ )
+
+    PhysicalDeviceBlendOperationAdvancedFeaturesEXT & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ )
+    PhysicalDeviceBlendOperationAdvancedFeaturesEXT & setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ )
     {
       advancedBlendCoherentOperations = advancedBlendCoherentOperations_;
       return *this;
@@ -16555,12 +34520,12 @@ public:
 
     operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>( this );
     }
 
     operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>( this );
     }
 
     bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const
@@ -16588,12 +34553,12 @@ public:
   {
     operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>( this );
     }
 
     operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>( this );
     }
 
     bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const
@@ -16627,743 +34592,145 @@ public:
   };
   static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" );
 
-  struct PhysicalDeviceInlineUniformBlockFeaturesEXT
+  struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
   {
-    operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const&() const
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV( Bool32 computeDerivativeGroupQuads_ = 0,
+                                                      Bool32 computeDerivativeGroupLinear_ = 0 )
+      : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ )
+      , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ )
+    {}
+
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
     {
-      return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this);
+      memcpy( this, &rhs, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) );
     }
 
-    operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT &()
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
     {
-      return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this);
+      memcpy( this, &rhs, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) );
+      return *this;
     }
 
-    bool operator==( PhysicalDeviceInlineUniformBlockFeaturesEXT const& rhs ) const
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupQuads( Bool32 computeDerivativeGroupQuads_ )
+    {
+      computeDerivativeGroupQuads = computeDerivativeGroupQuads_;
+      return *this;
+    }
+
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupLinear( Bool32 computeDerivativeGroupLinear_ )
+    {
+      computeDerivativeGroupLinear = computeDerivativeGroupLinear_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>( this );
+    }
+
+    operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>( this );
+    }
+
+    bool operator==( PhysicalDeviceComputeShaderDerivativesFeaturesNV const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( inlineUniformBlock == rhs.inlineUniformBlock )
-          && ( descriptorBindingInlineUniformBlockUpdateAfterBind == rhs.descriptorBindingInlineUniformBlockUpdateAfterBind );
+          && ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads )
+          && ( computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear );
     }
 
-    bool operator!=( PhysicalDeviceInlineUniformBlockFeaturesEXT const& rhs ) const
+    bool operator!=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT;
+    StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV;
 
   public:
     void* pNext = nullptr;
-    Bool32 inlineUniformBlock;
-    Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
+    Bool32 computeDerivativeGroupQuads;
+    Bool32 computeDerivativeGroupLinear;
   };
-  static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "struct and wrapper have different size!" );
 
-  struct PhysicalDeviceInlineUniformBlockPropertiesEXT
+  struct PhysicalDeviceConditionalRenderingFeaturesEXT
   {
-    operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const&() const
+    PhysicalDeviceConditionalRenderingFeaturesEXT( Bool32 conditionalRendering_ = 0,
+                                                   Bool32 inheritedConditionalRendering_ = 0 )
+      : conditionalRendering( conditionalRendering_ )
+      , inheritedConditionalRendering( inheritedConditionalRendering_ )
+    {}
+
+    PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs )
     {
-      return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this);
+      memcpy( this, &rhs, sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) );
     }
 
-    operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT &()
+    PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs )
     {
-      return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this);
+      memcpy( this, &rhs, sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) );
+      return *this;
     }
 
-    bool operator==( PhysicalDeviceInlineUniformBlockPropertiesEXT const& rhs ) const
+    PhysicalDeviceConditionalRenderingFeaturesEXT & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceConditionalRenderingFeaturesEXT & setConditionalRendering( Bool32 conditionalRendering_ )
+    {
+      conditionalRendering = conditionalRendering_;
+      return *this;
+    }
+
+    PhysicalDeviceConditionalRenderingFeaturesEXT & setInheritedConditionalRendering( Bool32 inheritedConditionalRendering_ )
+    {
+      inheritedConditionalRendering = inheritedConditionalRendering_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceConditionalRenderingFeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDeviceConditionalRenderingFeaturesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize )
-          && ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks )
-          && ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks == rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks )
-          && ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks )
-          && ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks == rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
+          && ( conditionalRendering == rhs.conditionalRendering )
+          && ( inheritedConditionalRendering == rhs.inheritedConditionalRendering );
     }
 
-    bool operator!=( PhysicalDeviceInlineUniformBlockPropertiesEXT const& rhs ) const
+    bool operator!=( PhysicalDeviceConditionalRenderingFeaturesEXT const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT;
+    StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT;
 
   public:
     void* pNext = nullptr;
-    uint32_t maxInlineUniformBlockSize;
-    uint32_t maxPerStageDescriptorInlineUniformBlocks;
-    uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
-    uint32_t maxDescriptorSetInlineUniformBlocks;
-    uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    Bool32 conditionalRendering;
+    Bool32 inheritedConditionalRendering;
   };
-  static_assert( sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockPropertiesEXT ), "struct and wrapper have different size!" );
-
-  struct WriteDescriptorSetInlineUniformBlockEXT
-  {
-    WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0,
-                                             const void* pData_ = nullptr )
-      : dataSize( dataSize_ )
-      , pData( pData_ )
-    {
-    }
-
-    WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) );
-    }
-
-    WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) );
-      return *this;
-    }
-    WriteDescriptorSetInlineUniformBlockEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    WriteDescriptorSetInlineUniformBlockEXT& setDataSize( uint32_t dataSize_ )
-    {
-      dataSize = dataSize_;
-      return *this;
-    }
-
-    WriteDescriptorSetInlineUniformBlockEXT& setPData( const void* pData_ )
-    {
-      pData = pData_;
-      return *this;
-    }
-
-    operator VkWriteDescriptorSetInlineUniformBlockEXT const&() const
-    {
-      return *reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(this);
-    }
-
-    operator VkWriteDescriptorSetInlineUniformBlockEXT &()
-    {
-      return *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(this);
-    }
-
-    bool operator==( WriteDescriptorSetInlineUniformBlockEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( dataSize == rhs.dataSize )
-          && ( pData == rhs.pData );
-    }
-
-    bool operator!=( WriteDescriptorSetInlineUniformBlockEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t dataSize;
-    const void* pData;
-  };
-  static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "struct and wrapper have different size!" );
-
-  struct DescriptorPoolInlineUniformBlockCreateInfoEXT
-  {
-    DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 )
-      : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
-    {
-    }
-
-    DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) );
-    }
-
-    DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) );
-      return *this;
-    }
-    DescriptorPoolInlineUniformBlockCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DescriptorPoolInlineUniformBlockCreateInfoEXT& setMaxInlineUniformBlockBindings( uint32_t maxInlineUniformBlockBindings_ )
-    {
-      maxInlineUniformBlockBindings = maxInlineUniformBlockBindings_;
-      return *this;
-    }
-
-    operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this);
-    }
-
-    operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this);
-    }
-
-    bool operator==( DescriptorPoolInlineUniformBlockCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings );
-    }
-
-    bool operator!=( DescriptorPoolInlineUniformBlockCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t maxInlineUniformBlockBindings;
-  };
-  static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  struct ImageFormatListCreateInfoKHR
-  {
-    ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0,
-                                  const Format* pViewFormats_ = nullptr )
-      : viewFormatCount( viewFormatCount_ )
-      , pViewFormats( pViewFormats_ )
-    {
-    }
-
-    ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) );
-    }
-
-    ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) );
-      return *this;
-    }
-    ImageFormatListCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageFormatListCreateInfoKHR& setViewFormatCount( uint32_t viewFormatCount_ )
-    {
-      viewFormatCount = viewFormatCount_;
-      return *this;
-    }
-
-    ImageFormatListCreateInfoKHR& setPViewFormats( const Format* pViewFormats_ )
-    {
-      pViewFormats = pViewFormats_;
-      return *this;
-    }
-
-    operator VkImageFormatListCreateInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkImageFormatListCreateInfoKHR*>(this);
-    }
-
-    operator VkImageFormatListCreateInfoKHR &()
-    {
-      return *reinterpret_cast<VkImageFormatListCreateInfoKHR*>(this);
-    }
-
-    bool operator==( ImageFormatListCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( viewFormatCount == rhs.viewFormatCount )
-          && ( pViewFormats == rhs.pViewFormats );
-    }
-
-    bool operator!=( ImageFormatListCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageFormatListCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t viewFormatCount;
-    const Format* pViewFormats;
-  };
-  static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  struct ValidationCacheCreateInfoEXT
-  {
-    ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_ = ValidationCacheCreateFlagsEXT(),
-                                  size_t initialDataSize_ = 0,
-                                  const void* pInitialData_ = nullptr )
-      : flags( flags_ )
-      , initialDataSize( initialDataSize_ )
-      , pInitialData( pInitialData_ )
-    {
-    }
-
-    ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) );
-    }
-
-    ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) );
-      return *this;
-    }
-    ValidationCacheCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ValidationCacheCreateInfoEXT& setFlags( ValidationCacheCreateFlagsEXT flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ValidationCacheCreateInfoEXT& setInitialDataSize( size_t initialDataSize_ )
-    {
-      initialDataSize = initialDataSize_;
-      return *this;
-    }
-
-    ValidationCacheCreateInfoEXT& setPInitialData( const void* pInitialData_ )
-    {
-      pInitialData = pInitialData_;
-      return *this;
-    }
-
-    operator VkValidationCacheCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkValidationCacheCreateInfoEXT*>(this);
-    }
-
-    operator VkValidationCacheCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkValidationCacheCreateInfoEXT*>(this);
-    }
-
-    bool operator==( ValidationCacheCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( initialDataSize == rhs.initialDataSize )
-          && ( pInitialData == rhs.pInitialData );
-    }
-
-    bool operator!=( ValidationCacheCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eValidationCacheCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ValidationCacheCreateFlagsEXT flags;
-    size_t initialDataSize;
-    const void* pInitialData;
-  };
-  static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  struct ShaderModuleValidationCacheCreateInfoEXT
-  {
-    ShaderModuleValidationCacheCreateInfoEXT( ValidationCacheEXT validationCache_ = ValidationCacheEXT() )
-      : validationCache( validationCache_ )
-    {
-    }
-
-    ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) );
-    }
-
-    ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) );
-      return *this;
-    }
-    ShaderModuleValidationCacheCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ShaderModuleValidationCacheCreateInfoEXT& setValidationCache( ValidationCacheEXT validationCache_ )
-    {
-      validationCache = validationCache_;
-      return *this;
-    }
-
-    operator VkShaderModuleValidationCacheCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(this);
-    }
-
-    operator VkShaderModuleValidationCacheCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(this);
-    }
-
-    bool operator==( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( validationCache == rhs.validationCache );
-    }
-
-    bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ValidationCacheEXT validationCache;
-  };
-  static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceMaintenance3Properties
-  {
-    operator VkPhysicalDeviceMaintenance3Properties const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(this);
-    }
-
-    operator VkPhysicalDeviceMaintenance3Properties &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(this);
-    }
-
-    bool operator==( PhysicalDeviceMaintenance3Properties const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors )
-          && ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize );
-    }
-
-    bool operator!=( PhysicalDeviceMaintenance3Properties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxPerSetDescriptors;
-    DeviceSize maxMemoryAllocationSize;
-  };
-  static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "struct and wrapper have different size!" );
-
-  using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
-
-  struct DescriptorSetLayoutSupport
-  {
-    operator VkDescriptorSetLayoutSupport const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorSetLayoutSupport*>(this);
-    }
-
-    operator VkDescriptorSetLayoutSupport &()
-    {
-      return *reinterpret_cast<VkDescriptorSetLayoutSupport*>(this);
-    }
-
-    bool operator==( DescriptorSetLayoutSupport const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( supported == rhs.supported );
-    }
-
-    bool operator!=( DescriptorSetLayoutSupport const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDescriptorSetLayoutSupport;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 supported;
-  };
-  static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "struct and wrapper have different size!" );
-
-  using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
-
-  struct PhysicalDeviceShaderDrawParameterFeatures
-  {
-    PhysicalDeviceShaderDrawParameterFeatures( Bool32 shaderDrawParameters_ = 0 )
-      : shaderDrawParameters( shaderDrawParameters_ )
-    {
-    }
-
-    PhysicalDeviceShaderDrawParameterFeatures( VkPhysicalDeviceShaderDrawParameterFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParameterFeatures ) );
-    }
-
-    PhysicalDeviceShaderDrawParameterFeatures& operator=( VkPhysicalDeviceShaderDrawParameterFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParameterFeatures ) );
-      return *this;
-    }
-    PhysicalDeviceShaderDrawParameterFeatures& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceShaderDrawParameterFeatures& setShaderDrawParameters( Bool32 shaderDrawParameters_ )
-    {
-      shaderDrawParameters = shaderDrawParameters_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceShaderDrawParameterFeatures const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceShaderDrawParameterFeatures*>(this);
-    }
-
-    operator VkPhysicalDeviceShaderDrawParameterFeatures &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures*>(this);
-    }
-
-    bool operator==( PhysicalDeviceShaderDrawParameterFeatures const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( shaderDrawParameters == rhs.shaderDrawParameters );
-    }
-
-    bool operator!=( PhysicalDeviceShaderDrawParameterFeatures const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceShaderDrawParameterFeatures;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 shaderDrawParameters;
-  };
-  static_assert( sizeof( PhysicalDeviceShaderDrawParameterFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParameterFeatures ), "struct and wrapper have different size!" );
-
-  struct DebugUtilsLabelEXT
-  {
-    DebugUtilsLabelEXT( const char* pLabelName_ = nullptr,
-                        std::array<float,4> const& color_ = { { 0, 0, 0, 0 } } )
-      : pLabelName( pLabelName_ )
-    {
-      memcpy( &color, color_.data(), 4 * sizeof( float ) );
-    }
-
-    DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugUtilsLabelEXT ) );
-    }
-
-    DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugUtilsLabelEXT ) );
-      return *this;
-    }
-    DebugUtilsLabelEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DebugUtilsLabelEXT& setPLabelName( const char* pLabelName_ )
-    {
-      pLabelName = pLabelName_;
-      return *this;
-    }
-
-    DebugUtilsLabelEXT& setColor( std::array<float,4> color_ )
-    {
-      memcpy( &color, color_.data(), 4 * sizeof( float ) );
-      return *this;
-    }
-
-    operator VkDebugUtilsLabelEXT const&() const
-    {
-      return *reinterpret_cast<const VkDebugUtilsLabelEXT*>(this);
-    }
-
-    operator VkDebugUtilsLabelEXT &()
-    {
-      return *reinterpret_cast<VkDebugUtilsLabelEXT*>(this);
-    }
-
-    bool operator==( DebugUtilsLabelEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pLabelName == rhs.pLabelName )
-          && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 );
-    }
-
-    bool operator!=( DebugUtilsLabelEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDebugUtilsLabelEXT;
-
-  public:
-    const void* pNext = nullptr;
-    const char* pLabelName;
-    float color[4];
-  };
-  static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "struct and wrapper have different size!" );
-
-  struct MemoryHostPointerPropertiesEXT
-  {
-    MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 )
-      : memoryTypeBits( memoryTypeBits_ )
-    {
-    }
-
-    MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) );
-    }
-
-    MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) );
-      return *this;
-    }
-    MemoryHostPointerPropertiesEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MemoryHostPointerPropertiesEXT& setMemoryTypeBits( uint32_t memoryTypeBits_ )
-    {
-      memoryTypeBits = memoryTypeBits_;
-      return *this;
-    }
-
-    operator VkMemoryHostPointerPropertiesEXT const&() const
-    {
-      return *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>(this);
-    }
-
-    operator VkMemoryHostPointerPropertiesEXT &()
-    {
-      return *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>(this);
-    }
-
-    bool operator==( MemoryHostPointerPropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memoryTypeBits == rhs.memoryTypeBits );
-    }
-
-    bool operator!=( MemoryHostPointerPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t memoryTypeBits;
-  };
-  static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceExternalMemoryHostPropertiesEXT
-  {
-    PhysicalDeviceExternalMemoryHostPropertiesEXT( DeviceSize minImportedHostPointerAlignment_ = 0 )
-      : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
-    {
-    }
-
-    PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) );
-    }
-
-    PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) );
-      return *this;
-    }
-    PhysicalDeviceExternalMemoryHostPropertiesEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalMemoryHostPropertiesEXT& setMinImportedHostPointerAlignment( DeviceSize minImportedHostPointerAlignment_ )
-    {
-      minImportedHostPointerAlignment = minImportedHostPointerAlignment_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this);
-    }
-
-    operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment );
-    }
-
-    bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    DeviceSize minImportedHostPointerAlignment;
-  };
-  static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "struct and wrapper have different size!" );
 
   struct PhysicalDeviceConservativeRasterizationPropertiesEXT
   {
@@ -17385,8 +34752,7 @@ public:
       , degenerateLinesRasterized( degenerateLinesRasterized_ )
       , fullyCoveredFragmentShaderInputVariable( fullyCoveredFragmentShaderInputVariable_ )
       , conservativeRasterizationPostDepthCoverage( conservativeRasterizationPostDepthCoverage_ )
-    {
-    }
+    {}
 
     PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs )
     {
@@ -17398,61 +34764,62 @@ public:
       memcpy( this, &rhs, sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) );
       return *this;
     }
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setPNext( void* pNext_ )
+
+    PhysicalDeviceConservativeRasterizationPropertiesEXT & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setPrimitiveOverestimationSize( float primitiveOverestimationSize_ )
+    PhysicalDeviceConservativeRasterizationPropertiesEXT & setPrimitiveOverestimationSize( float primitiveOverestimationSize_ )
     {
       primitiveOverestimationSize = primitiveOverestimationSize_;
       return *this;
     }
 
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setMaxExtraPrimitiveOverestimationSize( float maxExtraPrimitiveOverestimationSize_ )
+    PhysicalDeviceConservativeRasterizationPropertiesEXT & setMaxExtraPrimitiveOverestimationSize( float maxExtraPrimitiveOverestimationSize_ )
     {
       maxExtraPrimitiveOverestimationSize = maxExtraPrimitiveOverestimationSize_;
       return *this;
     }
 
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setExtraPrimitiveOverestimationSizeGranularity( float extraPrimitiveOverestimationSizeGranularity_ )
+    PhysicalDeviceConservativeRasterizationPropertiesEXT & setExtraPrimitiveOverestimationSizeGranularity( float extraPrimitiveOverestimationSizeGranularity_ )
     {
       extraPrimitiveOverestimationSizeGranularity = extraPrimitiveOverestimationSizeGranularity_;
       return *this;
     }
 
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setPrimitiveUnderestimation( Bool32 primitiveUnderestimation_ )
+    PhysicalDeviceConservativeRasterizationPropertiesEXT & setPrimitiveUnderestimation( Bool32 primitiveUnderestimation_ )
     {
       primitiveUnderestimation = primitiveUnderestimation_;
       return *this;
     }
 
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setConservativePointAndLineRasterization( Bool32 conservativePointAndLineRasterization_ )
+    PhysicalDeviceConservativeRasterizationPropertiesEXT & setConservativePointAndLineRasterization( Bool32 conservativePointAndLineRasterization_ )
     {
       conservativePointAndLineRasterization = conservativePointAndLineRasterization_;
       return *this;
     }
 
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setDegenerateTrianglesRasterized( Bool32 degenerateTrianglesRasterized_ )
+    PhysicalDeviceConservativeRasterizationPropertiesEXT & setDegenerateTrianglesRasterized( Bool32 degenerateTrianglesRasterized_ )
     {
       degenerateTrianglesRasterized = degenerateTrianglesRasterized_;
       return *this;
     }
 
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setDegenerateLinesRasterized( Bool32 degenerateLinesRasterized_ )
+    PhysicalDeviceConservativeRasterizationPropertiesEXT & setDegenerateLinesRasterized( Bool32 degenerateLinesRasterized_ )
     {
       degenerateLinesRasterized = degenerateLinesRasterized_;
       return *this;
     }
 
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setFullyCoveredFragmentShaderInputVariable( Bool32 fullyCoveredFragmentShaderInputVariable_ )
+    PhysicalDeviceConservativeRasterizationPropertiesEXT & setFullyCoveredFragmentShaderInputVariable( Bool32 fullyCoveredFragmentShaderInputVariable_ )
     {
       fullyCoveredFragmentShaderInputVariable = fullyCoveredFragmentShaderInputVariable_;
       return *this;
     }
 
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setConservativeRasterizationPostDepthCoverage( Bool32 conservativeRasterizationPostDepthCoverage_ )
+    PhysicalDeviceConservativeRasterizationPropertiesEXT & setConservativeRasterizationPostDepthCoverage( Bool32 conservativeRasterizationPostDepthCoverage_ )
     {
       conservativeRasterizationPostDepthCoverage = conservativeRasterizationPostDepthCoverage_;
       return *this;
@@ -17460,12 +34827,12 @@ public:
 
     operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>( this );
     }
 
     operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>( this );
     }
 
     bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) const
@@ -17505,64 +34872,65 @@ public:
   };
   static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "struct and wrapper have different size!" );
 
-  struct PhysicalDeviceShaderCorePropertiesAMD
+  struct PhysicalDeviceCornerSampledImageFeaturesNV
   {
-    operator VkPhysicalDeviceShaderCorePropertiesAMD const&() const
+    PhysicalDeviceCornerSampledImageFeaturesNV( Bool32 cornerSampledImage_ = 0 )
+      : cornerSampledImage( cornerSampledImage_ )
+    {}
+
+    PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
     {
-      return *reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(this);
+      memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) );
     }
 
-    operator VkPhysicalDeviceShaderCorePropertiesAMD &()
+    PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
     {
-      return *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(this);
+      memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) );
+      return *this;
     }
 
-    bool operator==( PhysicalDeviceShaderCorePropertiesAMD const& rhs ) const
+    PhysicalDeviceCornerSampledImageFeaturesNV & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceCornerSampledImageFeaturesNV & setCornerSampledImage( Bool32 cornerSampledImage_ )
+    {
+      cornerSampledImage = cornerSampledImage_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceCornerSampledImageFeaturesNV const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>( this );
+    }
+
+    operator VkPhysicalDeviceCornerSampledImageFeaturesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>( this );
+    }
+
+    bool operator==( PhysicalDeviceCornerSampledImageFeaturesNV const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( shaderEngineCount == rhs.shaderEngineCount )
-          && ( shaderArraysPerEngineCount == rhs.shaderArraysPerEngineCount )
-          && ( computeUnitsPerShaderArray == rhs.computeUnitsPerShaderArray )
-          && ( simdPerComputeUnit == rhs.simdPerComputeUnit )
-          && ( wavefrontsPerSimd == rhs.wavefrontsPerSimd )
-          && ( wavefrontSize == rhs.wavefrontSize )
-          && ( sgprsPerSimd == rhs.sgprsPerSimd )
-          && ( minSgprAllocation == rhs.minSgprAllocation )
-          && ( maxSgprAllocation == rhs.maxSgprAllocation )
-          && ( sgprAllocationGranularity == rhs.sgprAllocationGranularity )
-          && ( vgprsPerSimd == rhs.vgprsPerSimd )
-          && ( minVgprAllocation == rhs.minVgprAllocation )
-          && ( maxVgprAllocation == rhs.maxVgprAllocation )
-          && ( vgprAllocationGranularity == rhs.vgprAllocationGranularity );
+          && ( cornerSampledImage == rhs.cornerSampledImage );
     }
 
-    bool operator!=( PhysicalDeviceShaderCorePropertiesAMD const& rhs ) const
+    bool operator!=( PhysicalDeviceCornerSampledImageFeaturesNV const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD;
+    StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV;
 
   public:
     void* pNext = nullptr;
-    uint32_t shaderEngineCount;
-    uint32_t shaderArraysPerEngineCount;
-    uint32_t computeUnitsPerShaderArray;
-    uint32_t simdPerComputeUnit;
-    uint32_t wavefrontsPerSimd;
-    uint32_t wavefrontSize;
-    uint32_t sgprsPerSimd;
-    uint32_t minSgprAllocation;
-    uint32_t maxSgprAllocation;
-    uint32_t sgprAllocationGranularity;
-    uint32_t vgprsPerSimd;
-    uint32_t minVgprAllocation;
-    uint32_t maxVgprAllocation;
-    uint32_t vgprAllocationGranularity;
+    Bool32 cornerSampledImage;
   };
-  static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "struct and wrapper have different size!" );
 
   struct PhysicalDeviceDescriptorIndexingFeaturesEXT
   {
@@ -17606,8 +34974,7 @@ public:
       , descriptorBindingPartiallyBound( descriptorBindingPartiallyBound_ )
       , descriptorBindingVariableDescriptorCount( descriptorBindingVariableDescriptorCount_ )
       , runtimeDescriptorArray( runtimeDescriptorArray_ )
-    {
-    }
+    {}
 
     PhysicalDeviceDescriptorIndexingFeaturesEXT( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs )
     {
@@ -17619,127 +34986,128 @@ public:
       memcpy( this, &rhs, sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) );
       return *this;
     }
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setPNext( void* pNext_ )
+
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ )
     {
       shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ )
     {
       shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ )
     {
       shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ )
     {
       shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ )
     {
       shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ )
     {
       shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ )
     {
       shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ )
     {
       shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ )
     {
       shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ )
     {
       shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ )
     {
       descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ )
     {
       descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ )
     {
       descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ )
     {
       descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ )
     {
       descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ )
     {
       descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ )
     {
       descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ )
     {
       descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ )
     {
       descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_;
       return *this;
     }
 
-    PhysicalDeviceDescriptorIndexingFeaturesEXT& setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ )
+    PhysicalDeviceDescriptorIndexingFeaturesEXT & setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ )
     {
       runtimeDescriptorArray = runtimeDescriptorArray_;
       return *this;
@@ -17747,12 +35115,12 @@ public:
 
     operator VkPhysicalDeviceDescriptorIndexingFeaturesEXT const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>( this );
     }
 
     operator VkPhysicalDeviceDescriptorIndexingFeaturesEXT &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>( this );
     }
 
     bool operator==( PhysicalDeviceDescriptorIndexingFeaturesEXT const& rhs ) const
@@ -17818,12 +35186,12 @@ public:
   {
     operator VkPhysicalDeviceDescriptorIndexingPropertiesEXT const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>( this );
     }
 
     operator VkPhysicalDeviceDescriptorIndexingPropertiesEXT &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>( this );
     }
 
     bool operator==( PhysicalDeviceDescriptorIndexingPropertiesEXT const& rhs ) const
@@ -17891,1409 +35259,110 @@ public:
   };
   static_assert( sizeof( PhysicalDeviceDescriptorIndexingPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingPropertiesEXT ), "struct and wrapper have different size!" );
 
-  struct DescriptorSetVariableDescriptorCountAllocateInfoEXT
+  struct PhysicalDeviceDiscardRectanglePropertiesEXT
   {
-    DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0,
-                                                         const uint32_t* pDescriptorCounts_ = nullptr )
-      : descriptorSetCount( descriptorSetCount_ )
-      , pDescriptorCounts( pDescriptorCounts_ )
+    PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 )
+      : maxDiscardRectangles( maxDiscardRectangles_ )
+    {}
+
+    PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) );
     }
 
-    DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs )
+    PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
     {
-      memcpy( this, &rhs, sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) );
-    }
-
-    DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) );
       return *this;
     }
-    DescriptorSetVariableDescriptorCountAllocateInfoEXT& setPNext( const void* pNext_ )
+
+    PhysicalDeviceDiscardRectanglePropertiesEXT & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    DescriptorSetVariableDescriptorCountAllocateInfoEXT& setDescriptorSetCount( uint32_t descriptorSetCount_ )
+    PhysicalDeviceDiscardRectanglePropertiesEXT & setMaxDiscardRectangles( uint32_t maxDiscardRectangles_ )
     {
-      descriptorSetCount = descriptorSetCount_;
+      maxDiscardRectangles = maxDiscardRectangles_;
       return *this;
     }
 
-    DescriptorSetVariableDescriptorCountAllocateInfoEXT& setPDescriptorCounts( const uint32_t* pDescriptorCounts_ )
+    operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const&() const
     {
-      pDescriptorCounts = pDescriptorCounts_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>( this );
     }
 
-    operator VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const&() const
+    operator VkPhysicalDeviceDiscardRectanglePropertiesEXT &()
     {
-      return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>( this );
     }
 
-    operator VkDescriptorSetVariableDescriptorCountAllocateInfoEXT &()
-    {
-      return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this);
-    }
-
-    bool operator==( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& rhs ) const
+    bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( descriptorSetCount == rhs.descriptorSetCount )
-          && ( pDescriptorCounts == rhs.pDescriptorCounts );
+          && ( maxDiscardRectangles == rhs.maxDiscardRectangles );
     }
 
-    bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfoEXT const& rhs ) const
+    bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t descriptorSetCount;
-    const uint32_t* pDescriptorCounts;
-  };
-  static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "struct and wrapper have different size!" );
-
-  struct DescriptorSetVariableDescriptorCountLayoutSupportEXT
-  {
-    operator VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this);
-    }
-
-    operator VkDescriptorSetVariableDescriptorCountLayoutSupportEXT &()
-    {
-      return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this);
-    }
-
-    bool operator==( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount );
-    }
-
-    bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupportEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT;
+    StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT;
 
   public:
     void* pNext = nullptr;
-    uint32_t maxVariableDescriptorCount;
+    uint32_t maxDiscardRectangles;
   };
-  static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" );
 
-  struct SubpassEndInfoKHR
+  struct PhysicalDeviceDriverPropertiesKHR
   {
-    SubpassEndInfoKHR(  )
+    operator VkPhysicalDeviceDriverPropertiesKHR const&() const
     {
+      return *reinterpret_cast<const VkPhysicalDeviceDriverPropertiesKHR*>( this );
     }
 
-    SubpassEndInfoKHR( VkSubpassEndInfoKHR const & rhs )
+    operator VkPhysicalDeviceDriverPropertiesKHR &()
     {
-      memcpy( this, &rhs, sizeof( SubpassEndInfoKHR ) );
+      return *reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR*>( this );
     }
 
-    SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassEndInfoKHR ) );
-      return *this;
-    }
-    SubpassEndInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    operator VkSubpassEndInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkSubpassEndInfoKHR*>(this);
-    }
-
-    operator VkSubpassEndInfoKHR &()
-    {
-      return *reinterpret_cast<VkSubpassEndInfoKHR*>(this);
-    }
-
-    bool operator==( SubpassEndInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext );
-    }
-
-    bool operator!=( SubpassEndInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSubpassEndInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-  };
-  static_assert( sizeof( SubpassEndInfoKHR ) == sizeof( VkSubpassEndInfoKHR ), "struct and wrapper have different size!" );
-
-  struct PipelineVertexInputDivisorStateCreateInfoEXT
-  {
-    PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0,
-                                                  const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr )
-      : vertexBindingDivisorCount( vertexBindingDivisorCount_ )
-      , pVertexBindingDivisors( pVertexBindingDivisors_ )
-    {
-    }
-
-    PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) );
-    }
-
-    PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) );
-      return *this;
-    }
-    PipelineVertexInputDivisorStateCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineVertexInputDivisorStateCreateInfoEXT& setVertexBindingDivisorCount( uint32_t vertexBindingDivisorCount_ )
-    {
-      vertexBindingDivisorCount = vertexBindingDivisorCount_;
-      return *this;
-    }
-
-    PipelineVertexInputDivisorStateCreateInfoEXT& setPVertexBindingDivisors( const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ )
-    {
-      pVertexBindingDivisors = pVertexBindingDivisors_;
-      return *this;
-    }
-
-    operator VkPipelineVertexInputDivisorStateCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this);
-    }
-
-    operator VkPipelineVertexInputDivisorStateCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this);
-    }
-
-    bool operator==( PipelineVertexInputDivisorStateCreateInfoEXT const& rhs ) const
+    bool operator==( PhysicalDeviceDriverPropertiesKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( vertexBindingDivisorCount == rhs.vertexBindingDivisorCount )
-          && ( pVertexBindingDivisors == rhs.pVertexBindingDivisors );
+          && ( driverID == rhs.driverID )
+          && ( memcmp( driverName, rhs.driverName, VK_MAX_DRIVER_NAME_SIZE_KHR * sizeof( char ) ) == 0 )
+          && ( memcmp( driverInfo, rhs.driverInfo, VK_MAX_DRIVER_INFO_SIZE_KHR * sizeof( char ) ) == 0 )
+          && ( conformanceVersion == rhs.conformanceVersion );
     }
 
-    bool operator!=( PipelineVertexInputDivisorStateCreateInfoEXT const& rhs ) const
+    bool operator!=( PhysicalDeviceDriverPropertiesKHR const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t vertexBindingDivisorCount;
-    const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors;
-  };
-  static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT
-  {
-    PhysicalDeviceVertexAttributeDivisorPropertiesEXT( uint32_t maxVertexAttribDivisor_ = 0 )
-      : maxVertexAttribDivisor( maxVertexAttribDivisor_ )
-    {
-    }
-
-    PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) );
-    }
-
-    PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) );
-      return *this;
-    }
-    PhysicalDeviceVertexAttributeDivisorPropertiesEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceVertexAttributeDivisorPropertiesEXT& setMaxVertexAttribDivisor( uint32_t maxVertexAttribDivisor_ )
-    {
-      maxVertexAttribDivisor = maxVertexAttribDivisor_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this);
-    }
-
-    operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor );
-    }
-
-    bool operator!=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT;
+    StructureType sType = StructureType::ePhysicalDeviceDriverPropertiesKHR;
 
   public:
     void* pNext = nullptr;
-    uint32_t maxVertexAttribDivisor;
+    DriverIdKHR driverID;
+    char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR];
+    char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR];
+    ConformanceVersionKHR conformanceVersion;
   };
-  static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDevicePCIBusInfoPropertiesEXT
-  {
-    operator VkPhysicalDevicePCIBusInfoPropertiesEXT const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this);
-    }
-
-    operator VkPhysicalDevicePCIBusInfoPropertiesEXT &()
-    {
-      return *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDevicePCIBusInfoPropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pciDomain == rhs.pciDomain )
-          && ( pciBus == rhs.pciBus )
-          && ( pciDevice == rhs.pciDevice )
-          && ( pciFunction == rhs.pciFunction );
-    }
-
-    bool operator!=( PhysicalDevicePCIBusInfoPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint16_t pciDomain;
-    uint8_t pciBus;
-    uint8_t pciDevice;
-    uint8_t pciFunction;
-  };
-  static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct ImportAndroidHardwareBufferInfoANDROID
-  {
-    ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr )
-      : buffer( buffer_ )
-    {
-    }
-
-    ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportAndroidHardwareBufferInfoANDROID ) );
-    }
-
-    ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportAndroidHardwareBufferInfoANDROID ) );
-      return *this;
-    }
-    ImportAndroidHardwareBufferInfoANDROID& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportAndroidHardwareBufferInfoANDROID& setBuffer( struct AHardwareBuffer* buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    operator VkImportAndroidHardwareBufferInfoANDROID const&() const
-    {
-      return *reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(this);
-    }
-
-    operator VkImportAndroidHardwareBufferInfoANDROID &()
-    {
-      return *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(this);
-    }
-
-    bool operator==( ImportAndroidHardwareBufferInfoANDROID const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( buffer == rhs.buffer );
-    }
-
-    bool operator!=( ImportAndroidHardwareBufferInfoANDROID const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID;
-
-  public:
-    const void* pNext = nullptr;
-    struct AHardwareBuffer* buffer;
-  };
-  static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct AndroidHardwareBufferUsageANDROID
-  {
-    operator VkAndroidHardwareBufferUsageANDROID const&() const
-    {
-      return *reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(this);
-    }
-
-    operator VkAndroidHardwareBufferUsageANDROID &()
-    {
-      return *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(this);
-    }
-
-    bool operator==( AndroidHardwareBufferUsageANDROID const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage );
-    }
-
-    bool operator!=( AndroidHardwareBufferUsageANDROID const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID;
-
-  public:
-    void* pNext = nullptr;
-    uint64_t androidHardwareBufferUsage;
-  };
-  static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct AndroidHardwareBufferPropertiesANDROID
-  {
-    operator VkAndroidHardwareBufferPropertiesANDROID const&() const
-    {
-      return *reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID*>(this);
-    }
-
-    operator VkAndroidHardwareBufferPropertiesANDROID &()
-    {
-      return *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>(this);
-    }
-
-    bool operator==( AndroidHardwareBufferPropertiesANDROID const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( allocationSize == rhs.allocationSize )
-          && ( memoryTypeBits == rhs.memoryTypeBits );
-    }
-
-    bool operator!=( AndroidHardwareBufferPropertiesANDROID const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID;
-
-  public:
-    void* pNext = nullptr;
-    DeviceSize allocationSize;
-    uint32_t memoryTypeBits;
-  };
-  static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct MemoryGetAndroidHardwareBufferInfoANDROID
-  {
-    MemoryGetAndroidHardwareBufferInfoANDROID( DeviceMemory memory_ = DeviceMemory() )
-      : memory( memory_ )
-    {
-    }
-
-    MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) );
-    }
-
-    MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) );
-      return *this;
-    }
-    MemoryGetAndroidHardwareBufferInfoANDROID& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MemoryGetAndroidHardwareBufferInfoANDROID& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    operator VkMemoryGetAndroidHardwareBufferInfoANDROID const&() const
-    {
-      return *reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this);
-    }
-
-    operator VkMemoryGetAndroidHardwareBufferInfoANDROID &()
-    {
-      return *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this);
-    }
-
-    bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memory == rhs.memory );
-    }
-
-    bool operator!=( MemoryGetAndroidHardwareBufferInfoANDROID const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceMemory memory;
-  };
-  static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-  struct CommandBufferInheritanceConditionalRenderingInfoEXT
-  {
-    CommandBufferInheritanceConditionalRenderingInfoEXT( Bool32 conditionalRenderingEnable_ = 0 )
-      : conditionalRenderingEnable( conditionalRenderingEnable_ )
-    {
-    }
-
-    CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) );
-    }
-
-    CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) );
-      return *this;
-    }
-    CommandBufferInheritanceConditionalRenderingInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CommandBufferInheritanceConditionalRenderingInfoEXT& setConditionalRenderingEnable( Bool32 conditionalRenderingEnable_ )
-    {
-      conditionalRenderingEnable = conditionalRenderingEnable_;
-      return *this;
-    }
-
-    operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this);
-    }
-
-    operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &()
-    {
-      return *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this);
-    }
-
-    bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( conditionalRenderingEnable == rhs.conditionalRenderingEnable );
-    }
-
-    bool operator!=( CommandBufferInheritanceConditionalRenderingInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 conditionalRenderingEnable;
-  };
-  static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct ExternalFormatANDROID
-  {
-    ExternalFormatANDROID( uint64_t externalFormat_ = 0 )
-      : externalFormat( externalFormat_ )
-    {
-    }
-
-    ExternalFormatANDROID( VkExternalFormatANDROID const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalFormatANDROID ) );
-    }
-
-    ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalFormatANDROID ) );
-      return *this;
-    }
-    ExternalFormatANDROID& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExternalFormatANDROID& setExternalFormat( uint64_t externalFormat_ )
-    {
-      externalFormat = externalFormat_;
-      return *this;
-    }
-
-    operator VkExternalFormatANDROID const&() const
-    {
-      return *reinterpret_cast<const VkExternalFormatANDROID*>(this);
-    }
-
-    operator VkExternalFormatANDROID &()
-    {
-      return *reinterpret_cast<VkExternalFormatANDROID*>(this);
-    }
-
-    bool operator==( ExternalFormatANDROID const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( externalFormat == rhs.externalFormat );
-    }
-
-    bool operator!=( ExternalFormatANDROID const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalFormatANDROID;
-
-  public:
-    void* pNext = nullptr;
-    uint64_t externalFormat;
-  };
-  static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-  struct PhysicalDevice8BitStorageFeaturesKHR
-  {
-    PhysicalDevice8BitStorageFeaturesKHR( Bool32 storageBuffer8BitAccess_ = 0,
-                                          Bool32 uniformAndStorageBuffer8BitAccess_ = 0,
-                                          Bool32 storagePushConstant8_ = 0 )
-      : storageBuffer8BitAccess( storageBuffer8BitAccess_ )
-      , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ )
-      , storagePushConstant8( storagePushConstant8_ )
-    {
-    }
-
-    PhysicalDevice8BitStorageFeaturesKHR( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDevice8BitStorageFeaturesKHR ) );
-    }
-
-    PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDevice8BitStorageFeaturesKHR ) );
-      return *this;
-    }
-    PhysicalDevice8BitStorageFeaturesKHR& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDevice8BitStorageFeaturesKHR& setStorageBuffer8BitAccess( Bool32 storageBuffer8BitAccess_ )
-    {
-      storageBuffer8BitAccess = storageBuffer8BitAccess_;
-      return *this;
-    }
-
-    PhysicalDevice8BitStorageFeaturesKHR& setUniformAndStorageBuffer8BitAccess( Bool32 uniformAndStorageBuffer8BitAccess_ )
-    {
-      uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_;
-      return *this;
-    }
-
-    PhysicalDevice8BitStorageFeaturesKHR& setStoragePushConstant8( Bool32 storagePushConstant8_ )
-    {
-      storagePushConstant8 = storagePushConstant8_;
-      return *this;
-    }
-
-    operator VkPhysicalDevice8BitStorageFeaturesKHR const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDevice8BitStorageFeaturesKHR*>(this);
-    }
-
-    operator VkPhysicalDevice8BitStorageFeaturesKHR &()
-    {
-      return *reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(this);
-    }
-
-    bool operator==( PhysicalDevice8BitStorageFeaturesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess )
-          && ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess )
-          && ( storagePushConstant8 == rhs.storagePushConstant8 );
-    }
-
-    bool operator!=( PhysicalDevice8BitStorageFeaturesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDevice8BitStorageFeaturesKHR;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 storageBuffer8BitAccess;
-    Bool32 uniformAndStorageBuffer8BitAccess;
-    Bool32 storagePushConstant8;
-  };
-  static_assert( sizeof( PhysicalDevice8BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice8BitStorageFeaturesKHR ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceConditionalRenderingFeaturesEXT
-  {
-    PhysicalDeviceConditionalRenderingFeaturesEXT( Bool32 conditionalRendering_ = 0,
-                                                   Bool32 inheritedConditionalRendering_ = 0 )
-      : conditionalRendering( conditionalRendering_ )
-      , inheritedConditionalRendering( inheritedConditionalRendering_ )
-    {
-    }
-
-    PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) );
-    }
-
-    PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) );
-      return *this;
-    }
-    PhysicalDeviceConditionalRenderingFeaturesEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceConditionalRenderingFeaturesEXT& setConditionalRendering( Bool32 conditionalRendering_ )
-    {
-      conditionalRendering = conditionalRendering_;
-      return *this;
-    }
-
-    PhysicalDeviceConditionalRenderingFeaturesEXT& setInheritedConditionalRendering( Bool32 inheritedConditionalRendering_ )
-    {
-      inheritedConditionalRendering = inheritedConditionalRendering_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this);
-    }
-
-    operator VkPhysicalDeviceConditionalRenderingFeaturesEXT &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceConditionalRenderingFeaturesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( conditionalRendering == rhs.conditionalRendering )
-          && ( inheritedConditionalRendering == rhs.inheritedConditionalRendering );
-    }
-
-    bool operator!=( PhysicalDeviceConditionalRenderingFeaturesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 conditionalRendering;
-    Bool32 inheritedConditionalRendering;
-  };
-  static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceVulkanMemoryModelFeaturesKHR
-  {
-    operator VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this);
-    }
-
-    operator VkPhysicalDeviceVulkanMemoryModelFeaturesKHR &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceVulkanMemoryModelFeaturesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( vulkanMemoryModel == rhs.vulkanMemoryModel )
-          && ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope );
-    }
-
-    bool operator!=( PhysicalDeviceVulkanMemoryModelFeaturesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 vulkanMemoryModel;
-    Bool32 vulkanMemoryModelDeviceScope;
-  };
-  static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceShaderAtomicInt64FeaturesKHR
-  {
-    PhysicalDeviceShaderAtomicInt64FeaturesKHR( Bool32 shaderBufferInt64Atomics_ = 0,
-                                                Bool32 shaderSharedInt64Atomics_ = 0 )
-      : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ )
-      , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ )
-    {
-    }
-
-    PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) );
-    }
-
-    PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) );
-      return *this;
-    }
-    PhysicalDeviceShaderAtomicInt64FeaturesKHR& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceShaderAtomicInt64FeaturesKHR& setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ )
-    {
-      shaderBufferInt64Atomics = shaderBufferInt64Atomics_;
-      return *this;
-    }
-
-    PhysicalDeviceShaderAtomicInt64FeaturesKHR& setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ )
-    {
-      shaderSharedInt64Atomics = shaderSharedInt64Atomics_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(this);
-    }
-
-    operator VkPhysicalDeviceShaderAtomicInt64FeaturesKHR &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceShaderAtomicInt64FeaturesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics )
-          && ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics );
-    }
-
-    bool operator!=( PhysicalDeviceShaderAtomicInt64FeaturesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 shaderBufferInt64Atomics;
-    Bool32 shaderSharedInt64Atomics;
-  };
-  static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT
-  {
-    PhysicalDeviceVertexAttributeDivisorFeaturesEXT( Bool32 vertexAttributeInstanceRateDivisor_ = 0,
-                                                     Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 )
-      : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ )
-      , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ )
-    {
-    }
-
-    PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) );
-    }
-
-    PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) );
-      return *this;
-    }
-    PhysicalDeviceVertexAttributeDivisorFeaturesEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceVertexAttributeDivisorFeaturesEXT& setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ )
-    {
-      vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_;
-      return *this;
-    }
-
-    PhysicalDeviceVertexAttributeDivisorFeaturesEXT& setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ )
-    {
-      vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this);
-    }
-
-    operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor )
-          && ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor );
-    }
-
-    bool operator!=( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 vertexAttributeInstanceRateDivisor;
-    Bool32 vertexAttributeInstanceRateZeroDivisor;
-  };
-  static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "struct and wrapper have different size!" );
-
-  struct ImageViewASTCDecodeModeEXT
-  {
-    ImageViewASTCDecodeModeEXT( Format decodeMode_ = Format::eUndefined )
-      : decodeMode( decodeMode_ )
-    {
-    }
-
-    ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageViewASTCDecodeModeEXT ) );
-    }
-
-    ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageViewASTCDecodeModeEXT ) );
-      return *this;
-    }
-    ImageViewASTCDecodeModeEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageViewASTCDecodeModeEXT& setDecodeMode( Format decodeMode_ )
-    {
-      decodeMode = decodeMode_;
-      return *this;
-    }
-
-    operator VkImageViewASTCDecodeModeEXT const&() const
-    {
-      return *reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(this);
-    }
-
-    operator VkImageViewASTCDecodeModeEXT &()
-    {
-      return *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(this);
-    }
-
-    bool operator==( ImageViewASTCDecodeModeEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( decodeMode == rhs.decodeMode );
-    }
-
-    bool operator!=( ImageViewASTCDecodeModeEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageViewAstcDecodeModeEXT;
-
-  public:
-    const void* pNext = nullptr;
-    Format decodeMode;
-  };
-  static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceASTCDecodeFeaturesEXT
-  {
-    PhysicalDeviceASTCDecodeFeaturesEXT( Bool32 decodeModeSharedExponent_ = 0 )
-      : decodeModeSharedExponent( decodeModeSharedExponent_ )
-    {
-    }
-
-    PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) );
-    }
-
-    PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) );
-      return *this;
-    }
-    PhysicalDeviceASTCDecodeFeaturesEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceASTCDecodeFeaturesEXT& setDecodeModeSharedExponent( Bool32 decodeModeSharedExponent_ )
-    {
-      decodeModeSharedExponent = decodeModeSharedExponent_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceASTCDecodeFeaturesEXT const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this);
-    }
-
-    operator VkPhysicalDeviceASTCDecodeFeaturesEXT &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceASTCDecodeFeaturesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( decodeModeSharedExponent == rhs.decodeModeSharedExponent );
-    }
-
-    bool operator!=( PhysicalDeviceASTCDecodeFeaturesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 decodeModeSharedExponent;
-  };
-  static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceTransformFeedbackFeaturesEXT
-  {
-    PhysicalDeviceTransformFeedbackFeaturesEXT( Bool32 transformFeedback_ = 0,
-                                                Bool32 geometryStreams_ = 0 )
-      : transformFeedback( transformFeedback_ )
-      , geometryStreams( geometryStreams_ )
-    {
-    }
-
-    PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) );
-    }
-
-    PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) );
-      return *this;
-    }
-    PhysicalDeviceTransformFeedbackFeaturesEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceTransformFeedbackFeaturesEXT& setTransformFeedback( Bool32 transformFeedback_ )
-    {
-      transformFeedback = transformFeedback_;
-      return *this;
-    }
-
-    PhysicalDeviceTransformFeedbackFeaturesEXT& setGeometryStreams( Bool32 geometryStreams_ )
-    {
-      geometryStreams = geometryStreams_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this);
-    }
-
-    operator VkPhysicalDeviceTransformFeedbackFeaturesEXT &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceTransformFeedbackFeaturesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( transformFeedback == rhs.transformFeedback )
-          && ( geometryStreams == rhs.geometryStreams );
-    }
-
-    bool operator!=( PhysicalDeviceTransformFeedbackFeaturesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 transformFeedback;
-    Bool32 geometryStreams;
-  };
-  static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceTransformFeedbackPropertiesEXT
-  {
-    operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this);
-    }
-
-    operator VkPhysicalDeviceTransformFeedbackPropertiesEXT &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceTransformFeedbackPropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxTransformFeedbackStreams == rhs.maxTransformFeedbackStreams )
-          && ( maxTransformFeedbackBuffers == rhs.maxTransformFeedbackBuffers )
-          && ( maxTransformFeedbackBufferSize == rhs.maxTransformFeedbackBufferSize )
-          && ( maxTransformFeedbackStreamDataSize == rhs.maxTransformFeedbackStreamDataSize )
-          && ( maxTransformFeedbackBufferDataSize == rhs.maxTransformFeedbackBufferDataSize )
-          && ( maxTransformFeedbackBufferDataStride == rhs.maxTransformFeedbackBufferDataStride )
-          && ( transformFeedbackQueries == rhs.transformFeedbackQueries )
-          && ( transformFeedbackStreamsLinesTriangles == rhs.transformFeedbackStreamsLinesTriangles )
-          && ( transformFeedbackRasterizationStreamSelect == rhs.transformFeedbackRasterizationStreamSelect )
-          && ( transformFeedbackDraw == rhs.transformFeedbackDraw );
-    }
-
-    bool operator!=( PhysicalDeviceTransformFeedbackPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxTransformFeedbackStreams;
-    uint32_t maxTransformFeedbackBuffers;
-    DeviceSize maxTransformFeedbackBufferSize;
-    uint32_t maxTransformFeedbackStreamDataSize;
-    uint32_t maxTransformFeedbackBufferDataSize;
-    uint32_t maxTransformFeedbackBufferDataStride;
-    Bool32 transformFeedbackQueries;
-    Bool32 transformFeedbackStreamsLinesTriangles;
-    Bool32 transformFeedbackRasterizationStreamSelect;
-    Bool32 transformFeedbackDraw;
-  };
-  static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "struct and wrapper have different size!" );
-
-  struct PipelineRasterizationStateStreamCreateInfoEXT
-  {
-    PipelineRasterizationStateStreamCreateInfoEXT( PipelineRasterizationStateStreamCreateFlagsEXT flags_ = PipelineRasterizationStateStreamCreateFlagsEXT(),
-                                                   uint32_t rasterizationStream_ = 0 )
-      : flags( flags_ )
-      , rasterizationStream( rasterizationStream_ )
-    {
-    }
-
-    PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) );
-    }
-
-    PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) );
-      return *this;
-    }
-    PipelineRasterizationStateStreamCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineRasterizationStateStreamCreateInfoEXT& setFlags( PipelineRasterizationStateStreamCreateFlagsEXT flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineRasterizationStateStreamCreateInfoEXT& setRasterizationStream( uint32_t rasterizationStream_ )
-    {
-      rasterizationStream = rasterizationStream_;
-      return *this;
-    }
-
-    operator VkPipelineRasterizationStateStreamCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(this);
-    }
-
-    operator VkPipelineRasterizationStateStreamCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(this);
-    }
-
-    bool operator==( PipelineRasterizationStateStreamCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( rasterizationStream == rhs.rasterizationStream );
-    }
-
-    bool operator!=( PipelineRasterizationStateStreamCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineRasterizationStateStreamCreateFlagsEXT flags;
-    uint32_t rasterizationStream;
-  };
-  static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV
-  {
-    PhysicalDeviceRepresentativeFragmentTestFeaturesNV( Bool32 representativeFragmentTest_ = 0 )
-      : representativeFragmentTest( representativeFragmentTest_ )
-    {
-    }
-
-    PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) );
-    }
-
-    PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) );
-      return *this;
-    }
-    PhysicalDeviceRepresentativeFragmentTestFeaturesNV& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceRepresentativeFragmentTestFeaturesNV& setRepresentativeFragmentTest( Bool32 representativeFragmentTest_ )
-    {
-      representativeFragmentTest = representativeFragmentTest_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this);
-    }
-
-    operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this);
-    }
-
-    bool operator==( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( representativeFragmentTest == rhs.representativeFragmentTest );
-    }
-
-    bool operator!=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 representativeFragmentTest;
-  };
-  static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "struct and wrapper have different size!" );
-
-  struct PipelineRepresentativeFragmentTestStateCreateInfoNV
-  {
-    PipelineRepresentativeFragmentTestStateCreateInfoNV( Bool32 representativeFragmentTestEnable_ = 0 )
-      : representativeFragmentTestEnable( representativeFragmentTestEnable_ )
-    {
-    }
-
-    PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) );
-    }
-
-    PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) );
-      return *this;
-    }
-    PipelineRepresentativeFragmentTestStateCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineRepresentativeFragmentTestStateCreateInfoNV& setRepresentativeFragmentTestEnable( Bool32 representativeFragmentTestEnable_ )
-    {
-      representativeFragmentTestEnable = representativeFragmentTestEnable_;
-      return *this;
-    }
-
-    operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this);
-    }
-
-    operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV &()
-    {
-      return *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this);
-    }
-
-    bool operator==( PipelineRepresentativeFragmentTestStateCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable );
-    }
-
-    bool operator!=( PipelineRepresentativeFragmentTestStateCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 representativeFragmentTestEnable;
-  };
-  static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceDriverPropertiesKHR ) == sizeof( VkPhysicalDeviceDriverPropertiesKHR ), "struct and wrapper have different size!" );
 
   struct PhysicalDeviceExclusiveScissorFeaturesNV
   {
     PhysicalDeviceExclusiveScissorFeaturesNV( Bool32 exclusiveScissor_ = 0 )
       : exclusiveScissor( exclusiveScissor_ )
-    {
-    }
+    {}
 
     PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs )
     {
@@ -19305,13 +35374,14 @@ public:
       memcpy( this, &rhs, sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) );
       return *this;
     }
-    PhysicalDeviceExclusiveScissorFeaturesNV& setPNext( void* pNext_ )
+
+    PhysicalDeviceExclusiveScissorFeaturesNV & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PhysicalDeviceExclusiveScissorFeaturesNV& setExclusiveScissor( Bool32 exclusiveScissor_ )
+    PhysicalDeviceExclusiveScissorFeaturesNV & setExclusiveScissor( Bool32 exclusiveScissor_ )
     {
       exclusiveScissor = exclusiveScissor_;
       return *this;
@@ -19319,12 +35389,12 @@ public:
 
     operator VkPhysicalDeviceExclusiveScissorFeaturesNV const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>( this );
     }
 
     operator VkPhysicalDeviceExclusiveScissorFeaturesNV &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>( this );
     }
 
     bool operator==( PhysicalDeviceExclusiveScissorFeaturesNV const& rhs ) const
@@ -19348,1573 +35418,396 @@ public:
   };
   static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "struct and wrapper have different size!" );
 
-  struct PipelineViewportExclusiveScissorStateCreateInfoNV
+  struct PhysicalDeviceExternalBufferInfo
   {
-    PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0,
-                                                       const Rect2D* pExclusiveScissors_ = nullptr )
-      : exclusiveScissorCount( exclusiveScissorCount_ )
-      , pExclusiveScissors( pExclusiveScissors_ )
+    PhysicalDeviceExternalBufferInfo( BufferCreateFlags flags_ = BufferCreateFlags(),
+                                      BufferUsageFlags usage_ = BufferUsageFlags(),
+                                      ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+      : flags( flags_ )
+      , usage( usage_ )
+      , handleType( handleType_ )
+    {}
+
+    PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) );
     }
 
-    PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
+    PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs )
     {
-      memcpy( this, &rhs, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) );
-    }
-
-    PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) );
       return *this;
     }
-    PipelineViewportExclusiveScissorStateCreateInfoNV& setPNext( const void* pNext_ )
+
+    PhysicalDeviceExternalBufferInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PipelineViewportExclusiveScissorStateCreateInfoNV& setExclusiveScissorCount( uint32_t exclusiveScissorCount_ )
+    PhysicalDeviceExternalBufferInfo & setFlags( BufferCreateFlags flags_ )
     {
-      exclusiveScissorCount = exclusiveScissorCount_;
+      flags = flags_;
       return *this;
     }
 
-    PipelineViewportExclusiveScissorStateCreateInfoNV& setPExclusiveScissors( const Rect2D* pExclusiveScissors_ )
+    PhysicalDeviceExternalBufferInfo & setUsage( BufferUsageFlags usage_ )
     {
-      pExclusiveScissors = pExclusiveScissors_;
+      usage = usage_;
       return *this;
     }
 
-    operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const&() const
+    PhysicalDeviceExternalBufferInfo & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
     {
-      return *reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this);
+      handleType = handleType_;
+      return *this;
     }
 
-    operator VkPipelineViewportExclusiveScissorStateCreateInfoNV &()
+    operator VkPhysicalDeviceExternalBufferInfo const&() const
     {
-      return *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( this );
     }
 
-    bool operator==( PipelineViewportExclusiveScissorStateCreateInfoNV const& rhs ) const
+    operator VkPhysicalDeviceExternalBufferInfo &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>( this );
+    }
+
+    bool operator==( PhysicalDeviceExternalBufferInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( exclusiveScissorCount == rhs.exclusiveScissorCount )
-          && ( pExclusiveScissors == rhs.pExclusiveScissors );
+          && ( flags == rhs.flags )
+          && ( usage == rhs.usage )
+          && ( handleType == rhs.handleType );
     }
 
-    bool operator!=( PipelineViewportExclusiveScissorStateCreateInfoNV const& rhs ) const
+    bool operator!=( PhysicalDeviceExternalBufferInfo const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV;
+    StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo;
 
   public:
     const void* pNext = nullptr;
-    uint32_t exclusiveScissorCount;
-    const Rect2D* pExclusiveScissors;
+    BufferCreateFlags flags;
+    BufferUsageFlags usage;
+    ExternalMemoryHandleTypeFlagBits handleType;
   };
-  static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "struct and wrapper have different size!" );
 
-  struct PhysicalDeviceCornerSampledImageFeaturesNV
+  struct PhysicalDeviceExternalFenceInfo
   {
-    PhysicalDeviceCornerSampledImageFeaturesNV( Bool32 cornerSampledImage_ = 0 )
-      : cornerSampledImage( cornerSampledImage_ )
+    PhysicalDeviceExternalFenceInfo( ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+      : handleType( handleType_ )
+    {}
+
+    PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) );
     }
 
-    PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
+    PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs )
     {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) );
-    }
-
-    PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) );
       return *this;
     }
-    PhysicalDeviceCornerSampledImageFeaturesNV& setPNext( void* pNext_ )
+
+    PhysicalDeviceExternalFenceInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PhysicalDeviceCornerSampledImageFeaturesNV& setCornerSampledImage( Bool32 cornerSampledImage_ )
+    PhysicalDeviceExternalFenceInfo & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
     {
-      cornerSampledImage = cornerSampledImage_;
+      handleType = handleType_;
       return *this;
     }
 
-    operator VkPhysicalDeviceCornerSampledImageFeaturesNV const&() const
+    operator VkPhysicalDeviceExternalFenceInfo const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( this );
     }
 
-    operator VkPhysicalDeviceCornerSampledImageFeaturesNV &()
+    operator VkPhysicalDeviceExternalFenceInfo &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>( this );
     }
 
-    bool operator==( PhysicalDeviceCornerSampledImageFeaturesNV const& rhs ) const
+    bool operator==( PhysicalDeviceExternalFenceInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( cornerSampledImage == rhs.cornerSampledImage );
+          && ( handleType == rhs.handleType );
     }
 
-    bool operator!=( PhysicalDeviceCornerSampledImageFeaturesNV const& rhs ) const
+    bool operator!=( PhysicalDeviceExternalFenceInfo const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 cornerSampledImage;
-  };
-  static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
-  {
-    PhysicalDeviceComputeShaderDerivativesFeaturesNV( Bool32 computeDerivativeGroupQuads_ = 0,
-                                                      Bool32 computeDerivativeGroupLinear_ = 0 )
-      : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ )
-      , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ )
-    {
-    }
-
-    PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) );
-    }
-
-    PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) );
-      return *this;
-    }
-    PhysicalDeviceComputeShaderDerivativesFeaturesNV& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceComputeShaderDerivativesFeaturesNV& setComputeDerivativeGroupQuads( Bool32 computeDerivativeGroupQuads_ )
-    {
-      computeDerivativeGroupQuads = computeDerivativeGroupQuads_;
-      return *this;
-    }
-
-    PhysicalDeviceComputeShaderDerivativesFeaturesNV& setComputeDerivativeGroupLinear( Bool32 computeDerivativeGroupLinear_ )
-    {
-      computeDerivativeGroupLinear = computeDerivativeGroupLinear_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this);
-    }
-
-    operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this);
-    }
-
-    bool operator==( PhysicalDeviceComputeShaderDerivativesFeaturesNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads )
-          && ( computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear );
-    }
-
-    bool operator!=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 computeDerivativeGroupQuads;
-    Bool32 computeDerivativeGroupLinear;
-  };
-  static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
-  {
-    PhysicalDeviceFragmentShaderBarycentricFeaturesNV( Bool32 fragmentShaderBarycentric_ = 0 )
-      : fragmentShaderBarycentric( fragmentShaderBarycentric_ )
-    {
-    }
-
-    PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) );
-    }
-
-    PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) );
-      return *this;
-    }
-    PhysicalDeviceFragmentShaderBarycentricFeaturesNV& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceFragmentShaderBarycentricFeaturesNV& setFragmentShaderBarycentric( Bool32 fragmentShaderBarycentric_ )
-    {
-      fragmentShaderBarycentric = fragmentShaderBarycentric_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this);
-    }
-
-    operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this);
-    }
-
-    bool operator==( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric );
-    }
-
-    bool operator!=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 fragmentShaderBarycentric;
-  };
-  static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceShaderImageFootprintFeaturesNV
-  {
-    PhysicalDeviceShaderImageFootprintFeaturesNV( Bool32 imageFootprint_ = 0 )
-      : imageFootprint( imageFootprint_ )
-    {
-    }
-
-    PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) );
-    }
-
-    PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) );
-      return *this;
-    }
-    PhysicalDeviceShaderImageFootprintFeaturesNV& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceShaderImageFootprintFeaturesNV& setImageFootprint( Bool32 imageFootprint_ )
-    {
-      imageFootprint = imageFootprint_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this);
-    }
-
-    operator VkPhysicalDeviceShaderImageFootprintFeaturesNV &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this);
-    }
-
-    bool operator==( PhysicalDeviceShaderImageFootprintFeaturesNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( imageFootprint == rhs.imageFootprint );
-    }
-
-    bool operator!=( PhysicalDeviceShaderImageFootprintFeaturesNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 imageFootprint;
-  };
-  static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceShadingRateImageFeaturesNV
-  {
-    PhysicalDeviceShadingRateImageFeaturesNV( Bool32 shadingRateImage_ = 0,
-                                              Bool32 shadingRateCoarseSampleOrder_ = 0 )
-      : shadingRateImage( shadingRateImage_ )
-      , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ )
-    {
-    }
-
-    PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) );
-    }
-
-    PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) );
-      return *this;
-    }
-    PhysicalDeviceShadingRateImageFeaturesNV& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceShadingRateImageFeaturesNV& setShadingRateImage( Bool32 shadingRateImage_ )
-    {
-      shadingRateImage = shadingRateImage_;
-      return *this;
-    }
-
-    PhysicalDeviceShadingRateImageFeaturesNV& setShadingRateCoarseSampleOrder( Bool32 shadingRateCoarseSampleOrder_ )
-    {
-      shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceShadingRateImageFeaturesNV const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(this);
-    }
-
-    operator VkPhysicalDeviceShadingRateImageFeaturesNV &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(this);
-    }
-
-    bool operator==( PhysicalDeviceShadingRateImageFeaturesNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( shadingRateImage == rhs.shadingRateImage )
-          && ( shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder );
-    }
-
-    bool operator!=( PhysicalDeviceShadingRateImageFeaturesNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 shadingRateImage;
-    Bool32 shadingRateCoarseSampleOrder;
-  };
-  static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceShadingRateImagePropertiesNV
-  {
-    operator VkPhysicalDeviceShadingRateImagePropertiesNV const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(this);
-    }
-
-    operator VkPhysicalDeviceShadingRateImagePropertiesNV &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(this);
-    }
-
-    bool operator==( PhysicalDeviceShadingRateImagePropertiesNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( shadingRateTexelSize == rhs.shadingRateTexelSize )
-          && ( shadingRatePaletteSize == rhs.shadingRatePaletteSize )
-          && ( shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples );
-    }
-
-    bool operator!=( PhysicalDeviceShadingRateImagePropertiesNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV;
-
-  public:
-    void* pNext = nullptr;
-    Extent2D shadingRateTexelSize;
-    uint32_t shadingRatePaletteSize;
-    uint32_t shadingRateMaxCoarseSamples;
-  };
-  static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceMeshShaderFeaturesNV
-  {
-    PhysicalDeviceMeshShaderFeaturesNV( Bool32 taskShader_ = 0,
-                                        Bool32 meshShader_ = 0 )
-      : taskShader( taskShader_ )
-      , meshShader( meshShader_ )
-    {
-    }
-
-    PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) );
-    }
-
-    PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) );
-      return *this;
-    }
-    PhysicalDeviceMeshShaderFeaturesNV& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderFeaturesNV& setTaskShader( Bool32 taskShader_ )
-    {
-      taskShader = taskShader_;
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderFeaturesNV& setMeshShader( Bool32 meshShader_ )
-    {
-      meshShader = meshShader_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceMeshShaderFeaturesNV const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(this);
-    }
-
-    operator VkPhysicalDeviceMeshShaderFeaturesNV &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(this);
-    }
-
-    bool operator==( PhysicalDeviceMeshShaderFeaturesNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( taskShader == rhs.taskShader )
-          && ( meshShader == rhs.meshShader );
-    }
-
-    bool operator!=( PhysicalDeviceMeshShaderFeaturesNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 taskShader;
-    Bool32 meshShader;
-  };
-  static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceMeshShaderPropertiesNV
-  {
-    PhysicalDeviceMeshShaderPropertiesNV( uint32_t maxDrawMeshTasksCount_ = 0,
-                                          uint32_t maxTaskWorkGroupInvocations_ = 0,
-                                          std::array<uint32_t,3> const& maxTaskWorkGroupSize_ = { { 0, 0, 0 } },
-                                          uint32_t maxTaskTotalMemorySize_ = 0,
-                                          uint32_t maxTaskOutputCount_ = 0,
-                                          uint32_t maxMeshWorkGroupInvocations_ = 0,
-                                          std::array<uint32_t,3> const& maxMeshWorkGroupSize_ = { { 0, 0, 0 } },
-                                          uint32_t maxMeshTotalMemorySize_ = 0,
-                                          uint32_t maxMeshOutputVertices_ = 0,
-                                          uint32_t maxMeshOutputPrimitives_ = 0,
-                                          uint32_t maxMeshMultiviewViewCount_ = 0,
-                                          uint32_t meshOutputPerVertexGranularity_ = 0,
-                                          uint32_t meshOutputPerPrimitiveGranularity_ = 0 )
-      : maxDrawMeshTasksCount( maxDrawMeshTasksCount_ )
-      , maxTaskWorkGroupInvocations( maxTaskWorkGroupInvocations_ )
-      , maxTaskTotalMemorySize( maxTaskTotalMemorySize_ )
-      , maxTaskOutputCount( maxTaskOutputCount_ )
-      , maxMeshWorkGroupInvocations( maxMeshWorkGroupInvocations_ )
-      , maxMeshTotalMemorySize( maxMeshTotalMemorySize_ )
-      , maxMeshOutputVertices( maxMeshOutputVertices_ )
-      , maxMeshOutputPrimitives( maxMeshOutputPrimitives_ )
-      , maxMeshMultiviewViewCount( maxMeshMultiviewViewCount_ )
-      , meshOutputPerVertexGranularity( meshOutputPerVertexGranularity_ )
-      , meshOutputPerPrimitiveGranularity( meshOutputPerPrimitiveGranularity_ )
-    {
-      memcpy( &maxTaskWorkGroupSize, maxTaskWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
-      memcpy( &maxMeshWorkGroupSize, maxMeshWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderPropertiesNV ) );
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderPropertiesNV ) );
-      return *this;
-    }
-    PhysicalDeviceMeshShaderPropertiesNV& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& setMaxDrawMeshTasksCount( uint32_t maxDrawMeshTasksCount_ )
-    {
-      maxDrawMeshTasksCount = maxDrawMeshTasksCount_;
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& setMaxTaskWorkGroupInvocations( uint32_t maxTaskWorkGroupInvocations_ )
-    {
-      maxTaskWorkGroupInvocations = maxTaskWorkGroupInvocations_;
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& setMaxTaskWorkGroupSize( std::array<uint32_t,3> maxTaskWorkGroupSize_ )
-    {
-      memcpy( &maxTaskWorkGroupSize, maxTaskWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& setMaxTaskTotalMemorySize( uint32_t maxTaskTotalMemorySize_ )
-    {
-      maxTaskTotalMemorySize = maxTaskTotalMemorySize_;
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& setMaxTaskOutputCount( uint32_t maxTaskOutputCount_ )
-    {
-      maxTaskOutputCount = maxTaskOutputCount_;
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshWorkGroupInvocations( uint32_t maxMeshWorkGroupInvocations_ )
-    {
-      maxMeshWorkGroupInvocations = maxMeshWorkGroupInvocations_;
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshWorkGroupSize( std::array<uint32_t,3> maxMeshWorkGroupSize_ )
-    {
-      memcpy( &maxMeshWorkGroupSize, maxMeshWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshTotalMemorySize( uint32_t maxMeshTotalMemorySize_ )
-    {
-      maxMeshTotalMemorySize = maxMeshTotalMemorySize_;
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshOutputVertices( uint32_t maxMeshOutputVertices_ )
-    {
-      maxMeshOutputVertices = maxMeshOutputVertices_;
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshOutputPrimitives( uint32_t maxMeshOutputPrimitives_ )
-    {
-      maxMeshOutputPrimitives = maxMeshOutputPrimitives_;
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshMultiviewViewCount( uint32_t maxMeshMultiviewViewCount_ )
-    {
-      maxMeshMultiviewViewCount = maxMeshMultiviewViewCount_;
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& setMeshOutputPerVertexGranularity( uint32_t meshOutputPerVertexGranularity_ )
-    {
-      meshOutputPerVertexGranularity = meshOutputPerVertexGranularity_;
-      return *this;
-    }
-
-    PhysicalDeviceMeshShaderPropertiesNV& setMeshOutputPerPrimitiveGranularity( uint32_t meshOutputPerPrimitiveGranularity_ )
-    {
-      meshOutputPerPrimitiveGranularity = meshOutputPerPrimitiveGranularity_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceMeshShaderPropertiesNV const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(this);
-    }
-
-    operator VkPhysicalDeviceMeshShaderPropertiesNV &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(this);
-    }
-
-    bool operator==( PhysicalDeviceMeshShaderPropertiesNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount )
-          && ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations )
-          && ( memcmp( maxTaskWorkGroupSize, rhs.maxTaskWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
-          && ( maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize )
-          && ( maxTaskOutputCount == rhs.maxTaskOutputCount )
-          && ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations )
-          && ( memcmp( maxMeshWorkGroupSize, rhs.maxMeshWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
-          && ( maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize )
-          && ( maxMeshOutputVertices == rhs.maxMeshOutputVertices )
-          && ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives )
-          && ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount )
-          && ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity )
-          && ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity );
-    }
-
-    bool operator!=( PhysicalDeviceMeshShaderPropertiesNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxDrawMeshTasksCount;
-    uint32_t maxTaskWorkGroupInvocations;
-    uint32_t maxTaskWorkGroupSize[3];
-    uint32_t maxTaskTotalMemorySize;
-    uint32_t maxTaskOutputCount;
-    uint32_t maxMeshWorkGroupInvocations;
-    uint32_t maxMeshWorkGroupSize[3];
-    uint32_t maxMeshTotalMemorySize;
-    uint32_t maxMeshOutputVertices;
-    uint32_t maxMeshOutputPrimitives;
-    uint32_t maxMeshMultiviewViewCount;
-    uint32_t meshOutputPerVertexGranularity;
-    uint32_t meshOutputPerPrimitiveGranularity;
-  };
-  static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "struct and wrapper have different size!" );
-
-  struct GeometryTrianglesNV
-  {
-    GeometryTrianglesNV( Buffer vertexData_ = Buffer(),
-                         DeviceSize vertexOffset_ = 0,
-                         uint32_t vertexCount_ = 0,
-                         DeviceSize vertexStride_ = 0,
-                         Format vertexFormat_ = Format::eUndefined,
-                         Buffer indexData_ = Buffer(),
-                         DeviceSize indexOffset_ = 0,
-                         uint32_t indexCount_ = 0,
-                         IndexType indexType_ = IndexType::eUint16,
-                         Buffer transformData_ = Buffer(),
-                         DeviceSize transformOffset_ = 0 )
-      : vertexData( vertexData_ )
-      , vertexOffset( vertexOffset_ )
-      , vertexCount( vertexCount_ )
-      , vertexStride( vertexStride_ )
-      , vertexFormat( vertexFormat_ )
-      , indexData( indexData_ )
-      , indexOffset( indexOffset_ )
-      , indexCount( indexCount_ )
-      , indexType( indexType_ )
-      , transformData( transformData_ )
-      , transformOffset( transformOffset_ )
-    {
-    }
-
-    GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) );
-    }
-
-    GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) );
-      return *this;
-    }
-    GeometryTrianglesNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    GeometryTrianglesNV& setVertexData( Buffer vertexData_ )
-    {
-      vertexData = vertexData_;
-      return *this;
-    }
-
-    GeometryTrianglesNV& setVertexOffset( DeviceSize vertexOffset_ )
-    {
-      vertexOffset = vertexOffset_;
-      return *this;
-    }
-
-    GeometryTrianglesNV& setVertexCount( uint32_t vertexCount_ )
-    {
-      vertexCount = vertexCount_;
-      return *this;
-    }
-
-    GeometryTrianglesNV& setVertexStride( DeviceSize vertexStride_ )
-    {
-      vertexStride = vertexStride_;
-      return *this;
-    }
-
-    GeometryTrianglesNV& setVertexFormat( Format vertexFormat_ )
-    {
-      vertexFormat = vertexFormat_;
-      return *this;
-    }
-
-    GeometryTrianglesNV& setIndexData( Buffer indexData_ )
-    {
-      indexData = indexData_;
-      return *this;
-    }
-
-    GeometryTrianglesNV& setIndexOffset( DeviceSize indexOffset_ )
-    {
-      indexOffset = indexOffset_;
-      return *this;
-    }
-
-    GeometryTrianglesNV& setIndexCount( uint32_t indexCount_ )
-    {
-      indexCount = indexCount_;
-      return *this;
-    }
-
-    GeometryTrianglesNV& setIndexType( IndexType indexType_ )
-    {
-      indexType = indexType_;
-      return *this;
-    }
-
-    GeometryTrianglesNV& setTransformData( Buffer transformData_ )
-    {
-      transformData = transformData_;
-      return *this;
-    }
-
-    GeometryTrianglesNV& setTransformOffset( DeviceSize transformOffset_ )
-    {
-      transformOffset = transformOffset_;
-      return *this;
-    }
-
-    operator VkGeometryTrianglesNV const&() const
-    {
-      return *reinterpret_cast<const VkGeometryTrianglesNV*>(this);
-    }
-
-    operator VkGeometryTrianglesNV &()
-    {
-      return *reinterpret_cast<VkGeometryTrianglesNV*>(this);
-    }
-
-    bool operator==( GeometryTrianglesNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( vertexData == rhs.vertexData )
-          && ( vertexOffset == rhs.vertexOffset )
-          && ( vertexCount == rhs.vertexCount )
-          && ( vertexStride == rhs.vertexStride )
-          && ( vertexFormat == rhs.vertexFormat )
-          && ( indexData == rhs.indexData )
-          && ( indexOffset == rhs.indexOffset )
-          && ( indexCount == rhs.indexCount )
-          && ( indexType == rhs.indexType )
-          && ( transformData == rhs.transformData )
-          && ( transformOffset == rhs.transformOffset );
-    }
-
-    bool operator!=( GeometryTrianglesNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eGeometryTrianglesNV;
+    StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo;
 
   public:
     const void* pNext = nullptr;
-    Buffer vertexData;
-    DeviceSize vertexOffset;
-    uint32_t vertexCount;
-    DeviceSize vertexStride;
-    Format vertexFormat;
-    Buffer indexData;
-    DeviceSize indexOffset;
-    uint32_t indexCount;
-    IndexType indexType;
-    Buffer transformData;
-    DeviceSize transformOffset;
+    ExternalFenceHandleTypeFlagBits handleType;
   };
-  static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "struct and wrapper have different size!" );
 
-  struct GeometryAABBNV
+  struct PhysicalDeviceExternalImageFormatInfo
   {
-    GeometryAABBNV( Buffer aabbData_ = Buffer(),
-                    uint32_t numAABBs_ = 0,
-                    uint32_t stride_ = 0,
-                    DeviceSize offset_ = 0 )
-      : aabbData( aabbData_ )
-      , numAABBs( numAABBs_ )
-      , stride( stride_ )
-      , offset( offset_ )
+    PhysicalDeviceExternalImageFormatInfo( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+      : handleType( handleType_ )
+    {}
+
+    PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) );
     }
 
-    GeometryAABBNV( VkGeometryAABBNV const & rhs )
+    PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
     {
-      memcpy( this, &rhs, sizeof( GeometryAABBNV ) );
-    }
-
-    GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( GeometryAABBNV ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) );
       return *this;
     }
-    GeometryAABBNV& setPNext( const void* pNext_ )
+
+    PhysicalDeviceExternalImageFormatInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    GeometryAABBNV& setAabbData( Buffer aabbData_ )
+    PhysicalDeviceExternalImageFormatInfo & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
     {
-      aabbData = aabbData_;
+      handleType = handleType_;
       return *this;
     }
 
-    GeometryAABBNV& setNumAABBs( uint32_t numAABBs_ )
+    operator VkPhysicalDeviceExternalImageFormatInfo const&() const
     {
-      numAABBs = numAABBs_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>( this );
     }
 
-    GeometryAABBNV& setStride( uint32_t stride_ )
+    operator VkPhysicalDeviceExternalImageFormatInfo &()
     {
-      stride = stride_;
-      return *this;
+      return *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>( this );
     }
 
-    GeometryAABBNV& setOffset( DeviceSize offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    operator VkGeometryAABBNV const&() const
-    {
-      return *reinterpret_cast<const VkGeometryAABBNV*>(this);
-    }
-
-    operator VkGeometryAABBNV &()
-    {
-      return *reinterpret_cast<VkGeometryAABBNV*>(this);
-    }
-
-    bool operator==( GeometryAABBNV const& rhs ) const
+    bool operator==( PhysicalDeviceExternalImageFormatInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( aabbData == rhs.aabbData )
-          && ( numAABBs == rhs.numAABBs )
-          && ( stride == rhs.stride )
-          && ( offset == rhs.offset );
+          && ( handleType == rhs.handleType );
     }
 
-    bool operator!=( GeometryAABBNV const& rhs ) const
+    bool operator!=( PhysicalDeviceExternalImageFormatInfo const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eGeometryAabbNV;
+    StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo;
 
   public:
     const void* pNext = nullptr;
-    Buffer aabbData;
-    uint32_t numAABBs;
-    uint32_t stride;
-    DeviceSize offset;
+    ExternalMemoryHandleTypeFlagBits handleType;
   };
-  static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "struct and wrapper have different size!" );
 
-  struct GeometryDataNV
+  struct PhysicalDeviceExternalMemoryHostPropertiesEXT
   {
-    GeometryDataNV( GeometryTrianglesNV triangles_ = GeometryTrianglesNV(),
-                    GeometryAABBNV aabbs_ = GeometryAABBNV() )
-      : triangles( triangles_ )
-      , aabbs( aabbs_ )
+    PhysicalDeviceExternalMemoryHostPropertiesEXT( DeviceSize minImportedHostPointerAlignment_ = 0 )
+      : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
+    {}
+
+    PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) );
     }
 
-    GeometryDataNV( VkGeometryDataNV const & rhs )
+    PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
     {
-      memcpy( this, &rhs, sizeof( GeometryDataNV ) );
-    }
-
-    GeometryDataNV& operator=( VkGeometryDataNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( GeometryDataNV ) );
-      return *this;
-    }
-    GeometryDataNV& setTriangles( GeometryTrianglesNV triangles_ )
-    {
-      triangles = triangles_;
+      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) );
       return *this;
     }
 
-    GeometryDataNV& setAabbs( GeometryAABBNV aabbs_ )
-    {
-      aabbs = aabbs_;
-      return *this;
-    }
-
-    operator VkGeometryDataNV const&() const
-    {
-      return *reinterpret_cast<const VkGeometryDataNV*>(this);
-    }
-
-    operator VkGeometryDataNV &()
-    {
-      return *reinterpret_cast<VkGeometryDataNV*>(this);
-    }
-
-    bool operator==( GeometryDataNV const& rhs ) const
-    {
-      return ( triangles == rhs.triangles )
-          && ( aabbs == rhs.aabbs );
-    }
-
-    bool operator!=( GeometryDataNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    GeometryTrianglesNV triangles;
-    GeometryAABBNV aabbs;
-  };
-  static_assert( sizeof( GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" );
-
-  struct BindAccelerationStructureMemoryInfoNV
-  {
-    BindAccelerationStructureMemoryInfoNV( AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV(),
-                                           DeviceMemory memory_ = DeviceMemory(),
-                                           DeviceSize memoryOffset_ = 0,
-                                           uint32_t deviceIndexCount_ = 0,
-                                           const uint32_t* pDeviceIndices_ = nullptr )
-      : accelerationStructure( accelerationStructure_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
-      , deviceIndexCount( deviceIndexCount_ )
-      , pDeviceIndices( pDeviceIndices_ )
-    {
-    }
-
-    BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) );
-    }
-
-    BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) );
-      return *this;
-    }
-    BindAccelerationStructureMemoryInfoNV& setPNext( const void* pNext_ )
+    PhysicalDeviceExternalMemoryHostPropertiesEXT & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    BindAccelerationStructureMemoryInfoNV& setAccelerationStructure( AccelerationStructureNV accelerationStructure_ )
+    PhysicalDeviceExternalMemoryHostPropertiesEXT & setMinImportedHostPointerAlignment( DeviceSize minImportedHostPointerAlignment_ )
     {
-      accelerationStructure = accelerationStructure_;
+      minImportedHostPointerAlignment = minImportedHostPointerAlignment_;
       return *this;
     }
 
-    BindAccelerationStructureMemoryInfoNV& setMemory( DeviceMemory memory_ )
+    operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const&() const
     {
-      memory = memory_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>( this );
     }
 
-    BindAccelerationStructureMemoryInfoNV& setMemoryOffset( DeviceSize memoryOffset_ )
+    operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT &()
     {
-      memoryOffset = memoryOffset_;
-      return *this;
+      return *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>( this );
     }
 
-    BindAccelerationStructureMemoryInfoNV& setDeviceIndexCount( uint32_t deviceIndexCount_ )
-    {
-      deviceIndexCount = deviceIndexCount_;
-      return *this;
-    }
-
-    BindAccelerationStructureMemoryInfoNV& setPDeviceIndices( const uint32_t* pDeviceIndices_ )
-    {
-      pDeviceIndices = pDeviceIndices_;
-      return *this;
-    }
-
-    operator VkBindAccelerationStructureMemoryInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>(this);
-    }
-
-    operator VkBindAccelerationStructureMemoryInfoNV &()
-    {
-      return *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV*>(this);
-    }
-
-    bool operator==( BindAccelerationStructureMemoryInfoNV const& rhs ) const
+    bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( accelerationStructure == rhs.accelerationStructure )
-          && ( memory == rhs.memory )
-          && ( memoryOffset == rhs.memoryOffset )
-          && ( deviceIndexCount == rhs.deviceIndexCount )
-          && ( pDeviceIndices == rhs.pDeviceIndices );
+          && ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment );
     }
 
-    bool operator!=( BindAccelerationStructureMemoryInfoNV const& rhs ) const
+    bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    AccelerationStructureNV accelerationStructure;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
-    uint32_t deviceIndexCount;
-    const uint32_t* pDeviceIndices;
-  };
-  static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "struct and wrapper have different size!" );
-
-  struct WriteDescriptorSetAccelerationStructureNV
-  {
-    WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0,
-                                               const AccelerationStructureNV* pAccelerationStructures_ = nullptr )
-      : accelerationStructureCount( accelerationStructureCount_ )
-      , pAccelerationStructures( pAccelerationStructures_ )
-    {
-    }
-
-    WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) );
-    }
-
-    WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) );
-      return *this;
-    }
-    WriteDescriptorSetAccelerationStructureNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    WriteDescriptorSetAccelerationStructureNV& setAccelerationStructureCount( uint32_t accelerationStructureCount_ )
-    {
-      accelerationStructureCount = accelerationStructureCount_;
-      return *this;
-    }
-
-    WriteDescriptorSetAccelerationStructureNV& setPAccelerationStructures( const AccelerationStructureNV* pAccelerationStructures_ )
-    {
-      pAccelerationStructures = pAccelerationStructures_;
-      return *this;
-    }
-
-    operator VkWriteDescriptorSetAccelerationStructureNV const&() const
-    {
-      return *reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(this);
-    }
-
-    operator VkWriteDescriptorSetAccelerationStructureNV &()
-    {
-      return *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(this);
-    }
-
-    bool operator==( WriteDescriptorSetAccelerationStructureNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( accelerationStructureCount == rhs.accelerationStructureCount )
-          && ( pAccelerationStructures == rhs.pAccelerationStructures );
-    }
-
-    bool operator!=( WriteDescriptorSetAccelerationStructureNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t accelerationStructureCount;
-    const AccelerationStructureNV* pAccelerationStructures;
-  };
-  static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceRayTracingPropertiesNV
-  {
-    PhysicalDeviceRayTracingPropertiesNV( uint32_t shaderGroupHandleSize_ = 0,
-                                          uint32_t maxRecursionDepth_ = 0,
-                                          uint32_t maxShaderGroupStride_ = 0,
-                                          uint32_t shaderGroupBaseAlignment_ = 0,
-                                          uint64_t maxGeometryCount_ = 0,
-                                          uint64_t maxInstanceCount_ = 0,
-                                          uint64_t maxTriangleCount_ = 0,
-                                          uint32_t maxDescriptorSetAccelerationStructures_ = 0 )
-      : shaderGroupHandleSize( shaderGroupHandleSize_ )
-      , maxRecursionDepth( maxRecursionDepth_ )
-      , maxShaderGroupStride( maxShaderGroupStride_ )
-      , shaderGroupBaseAlignment( shaderGroupBaseAlignment_ )
-      , maxGeometryCount( maxGeometryCount_ )
-      , maxInstanceCount( maxInstanceCount_ )
-      , maxTriangleCount( maxTriangleCount_ )
-      , maxDescriptorSetAccelerationStructures( maxDescriptorSetAccelerationStructures_ )
-    {
-    }
-
-    PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceRayTracingPropertiesNV ) );
-    }
-
-    PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceRayTracingPropertiesNV ) );
-      return *this;
-    }
-    PhysicalDeviceRayTracingPropertiesNV& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceRayTracingPropertiesNV& setShaderGroupHandleSize( uint32_t shaderGroupHandleSize_ )
-    {
-      shaderGroupHandleSize = shaderGroupHandleSize_;
-      return *this;
-    }
-
-    PhysicalDeviceRayTracingPropertiesNV& setMaxRecursionDepth( uint32_t maxRecursionDepth_ )
-    {
-      maxRecursionDepth = maxRecursionDepth_;
-      return *this;
-    }
-
-    PhysicalDeviceRayTracingPropertiesNV& setMaxShaderGroupStride( uint32_t maxShaderGroupStride_ )
-    {
-      maxShaderGroupStride = maxShaderGroupStride_;
-      return *this;
-    }
-
-    PhysicalDeviceRayTracingPropertiesNV& setShaderGroupBaseAlignment( uint32_t shaderGroupBaseAlignment_ )
-    {
-      shaderGroupBaseAlignment = shaderGroupBaseAlignment_;
-      return *this;
-    }
-
-    PhysicalDeviceRayTracingPropertiesNV& setMaxGeometryCount( uint64_t maxGeometryCount_ )
-    {
-      maxGeometryCount = maxGeometryCount_;
-      return *this;
-    }
-
-    PhysicalDeviceRayTracingPropertiesNV& setMaxInstanceCount( uint64_t maxInstanceCount_ )
-    {
-      maxInstanceCount = maxInstanceCount_;
-      return *this;
-    }
-
-    PhysicalDeviceRayTracingPropertiesNV& setMaxTriangleCount( uint64_t maxTriangleCount_ )
-    {
-      maxTriangleCount = maxTriangleCount_;
-      return *this;
-    }
-
-    PhysicalDeviceRayTracingPropertiesNV& setMaxDescriptorSetAccelerationStructures( uint32_t maxDescriptorSetAccelerationStructures_ )
-    {
-      maxDescriptorSetAccelerationStructures = maxDescriptorSetAccelerationStructures_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceRayTracingPropertiesNV const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(this);
-    }
-
-    operator VkPhysicalDeviceRayTracingPropertiesNV &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(this);
-    }
-
-    bool operator==( PhysicalDeviceRayTracingPropertiesNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( shaderGroupHandleSize == rhs.shaderGroupHandleSize )
-          && ( maxRecursionDepth == rhs.maxRecursionDepth )
-          && ( maxShaderGroupStride == rhs.maxShaderGroupStride )
-          && ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment )
-          && ( maxGeometryCount == rhs.maxGeometryCount )
-          && ( maxInstanceCount == rhs.maxInstanceCount )
-          && ( maxTriangleCount == rhs.maxTriangleCount )
-          && ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures );
-    }
-
-    bool operator!=( PhysicalDeviceRayTracingPropertiesNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV;
+    StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT;
 
   public:
     void* pNext = nullptr;
-    uint32_t shaderGroupHandleSize;
-    uint32_t maxRecursionDepth;
-    uint32_t maxShaderGroupStride;
-    uint32_t shaderGroupBaseAlignment;
-    uint64_t maxGeometryCount;
-    uint64_t maxInstanceCount;
-    uint64_t maxTriangleCount;
-    uint32_t maxDescriptorSetAccelerationStructures;
+    DeviceSize minImportedHostPointerAlignment;
   };
-  static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" );
 
-  struct PhysicalDeviceImageDrmFormatModifierInfoEXT
+  struct PhysicalDeviceExternalSemaphoreInfo
   {
-    PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0,
-                                                 SharingMode sharingMode_ = SharingMode::eExclusive,
-                                                 uint32_t queueFamilyIndexCount_ = 0,
-                                                 const uint32_t* pQueueFamilyIndices_ = nullptr )
-      : drmFormatModifier( drmFormatModifier_ )
-      , sharingMode( sharingMode_ )
-      , queueFamilyIndexCount( queueFamilyIndexCount_ )
-      , pQueueFamilyIndices( pQueueFamilyIndices_ )
+    PhysicalDeviceExternalSemaphoreInfo( ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+      : handleType( handleType_ )
+    {}
+
+    PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) );
     }
 
-    PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
+    PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
     {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) );
-    }
-
-    PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) );
       return *this;
     }
-    PhysicalDeviceImageDrmFormatModifierInfoEXT& setPNext( const void* pNext_ )
+
+    PhysicalDeviceExternalSemaphoreInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PhysicalDeviceImageDrmFormatModifierInfoEXT& setDrmFormatModifier( uint64_t drmFormatModifier_ )
+    PhysicalDeviceExternalSemaphoreInfo & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
     {
-      drmFormatModifier = drmFormatModifier_;
+      handleType = handleType_;
       return *this;
     }
 
-    PhysicalDeviceImageDrmFormatModifierInfoEXT& setSharingMode( SharingMode sharingMode_ )
+    operator VkPhysicalDeviceExternalSemaphoreInfo const&() const
     {
-      sharingMode = sharingMode_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( this );
     }
 
-    PhysicalDeviceImageDrmFormatModifierInfoEXT& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+    operator VkPhysicalDeviceExternalSemaphoreInfo &()
     {
-      queueFamilyIndexCount = queueFamilyIndexCount_;
-      return *this;
+      return *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>( this );
     }
 
-    PhysicalDeviceImageDrmFormatModifierInfoEXT& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
-    {
-      pQueueFamilyIndices = pQueueFamilyIndices_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this);
-    }
-
-    operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceImageDrmFormatModifierInfoEXT const& rhs ) const
+    bool operator==( PhysicalDeviceExternalSemaphoreInfo const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( drmFormatModifier == rhs.drmFormatModifier )
-          && ( sharingMode == rhs.sharingMode )
-          && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
-          && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
+          && ( handleType == rhs.handleType );
     }
 
-    bool operator!=( PhysicalDeviceImageDrmFormatModifierInfoEXT const& rhs ) const
+    bool operator!=( PhysicalDeviceExternalSemaphoreInfo const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT;
+    StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo;
 
   public:
     const void* pNext = nullptr;
-    uint64_t drmFormatModifier;
-    SharingMode sharingMode;
-    uint32_t queueFamilyIndexCount;
-    const uint32_t* pQueueFamilyIndices;
+    ExternalSemaphoreHandleTypeFlagBits handleType;
   };
-  static_assert( sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) == sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "struct and wrapper have different size!" );
 
-  struct ImageDrmFormatModifierListCreateInfoEXT
+  struct PhysicalDeviceFeatures2
   {
-    ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0,
-                                             const uint64_t* pDrmFormatModifiers_ = nullptr )
-      : drmFormatModifierCount( drmFormatModifierCount_ )
-      , pDrmFormatModifiers( pDrmFormatModifiers_ )
+    PhysicalDeviceFeatures2( PhysicalDeviceFeatures features_ = PhysicalDeviceFeatures() )
+      : features( features_ )
+    {}
+
+    PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2 ) );
     }
 
-    ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
+    PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs )
     {
-      memcpy( this, &rhs, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) );
-    }
-
-    ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2 ) );
       return *this;
     }
-    ImageDrmFormatModifierListCreateInfoEXT& setPNext( const void* pNext_ )
+
+    PhysicalDeviceFeatures2 & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    ImageDrmFormatModifierListCreateInfoEXT& setDrmFormatModifierCount( uint32_t drmFormatModifierCount_ )
+    PhysicalDeviceFeatures2 & setFeatures( PhysicalDeviceFeatures features_ )
     {
-      drmFormatModifierCount = drmFormatModifierCount_;
+      features = features_;
       return *this;
     }
 
-    ImageDrmFormatModifierListCreateInfoEXT& setPDrmFormatModifiers( const uint64_t* pDrmFormatModifiers_ )
+    operator VkPhysicalDeviceFeatures2 const&() const
     {
-      pDrmFormatModifiers = pDrmFormatModifiers_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDeviceFeatures2*>( this );
     }
 
-    operator VkImageDrmFormatModifierListCreateInfoEXT const&() const
+    operator VkPhysicalDeviceFeatures2 &()
     {
-      return *reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceFeatures2*>( this );
     }
 
-    operator VkImageDrmFormatModifierListCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(this);
-    }
-
-    bool operator==( ImageDrmFormatModifierListCreateInfoEXT const& rhs ) const
+    bool operator==( PhysicalDeviceFeatures2 const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( drmFormatModifierCount == rhs.drmFormatModifierCount )
-          && ( pDrmFormatModifiers == rhs.pDrmFormatModifiers );
+          && ( features == rhs.features );
     }
 
-    bool operator!=( ImageDrmFormatModifierListCreateInfoEXT const& rhs ) const
+    bool operator!=( PhysicalDeviceFeatures2 const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t drmFormatModifierCount;
-    const uint64_t* pDrmFormatModifiers;
-  };
-  static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  struct ImageDrmFormatModifierExplicitCreateInfoEXT
-  {
-    ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0,
-                                                 uint32_t drmFormatModifierPlaneCount_ = 0,
-                                                 const SubresourceLayout* pPlaneLayouts_ = nullptr )
-      : drmFormatModifier( drmFormatModifier_ )
-      , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ )
-      , pPlaneLayouts( pPlaneLayouts_ )
-    {
-    }
-
-    ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) );
-    }
-
-    ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) );
-      return *this;
-    }
-    ImageDrmFormatModifierExplicitCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageDrmFormatModifierExplicitCreateInfoEXT& setDrmFormatModifier( uint64_t drmFormatModifier_ )
-    {
-      drmFormatModifier = drmFormatModifier_;
-      return *this;
-    }
-
-    ImageDrmFormatModifierExplicitCreateInfoEXT& setDrmFormatModifierPlaneCount( uint32_t drmFormatModifierPlaneCount_ )
-    {
-      drmFormatModifierPlaneCount = drmFormatModifierPlaneCount_;
-      return *this;
-    }
-
-    ImageDrmFormatModifierExplicitCreateInfoEXT& setPPlaneLayouts( const SubresourceLayout* pPlaneLayouts_ )
-    {
-      pPlaneLayouts = pPlaneLayouts_;
-      return *this;
-    }
-
-    operator VkImageDrmFormatModifierExplicitCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this);
-    }
-
-    operator VkImageDrmFormatModifierExplicitCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this);
-    }
-
-    bool operator==( ImageDrmFormatModifierExplicitCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( drmFormatModifier == rhs.drmFormatModifier )
-          && ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount )
-          && ( pPlaneLayouts == rhs.pPlaneLayouts );
-    }
-
-    bool operator!=( ImageDrmFormatModifierExplicitCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint64_t drmFormatModifier;
-    uint32_t drmFormatModifierPlaneCount;
-    const SubresourceLayout* pPlaneLayouts;
-  };
-  static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  struct ImageDrmFormatModifierPropertiesEXT
-  {
-    operator VkImageDrmFormatModifierPropertiesEXT const&() const
-    {
-      return *reinterpret_cast<const VkImageDrmFormatModifierPropertiesEXT*>(this);
-    }
-
-    operator VkImageDrmFormatModifierPropertiesEXT &()
-    {
-      return *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>(this);
-    }
-
-    bool operator==( ImageDrmFormatModifierPropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( drmFormatModifier == rhs.drmFormatModifier );
-    }
-
-    bool operator!=( ImageDrmFormatModifierPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT;
+    StructureType sType = StructureType::ePhysicalDeviceFeatures2;
 
   public:
     void* pNext = nullptr;
-    uint64_t drmFormatModifier;
+    PhysicalDeviceFeatures features;
   };
-  static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "struct and wrapper have different size!" );
 
   struct PhysicalDeviceFragmentDensityMapFeaturesEXT
   {
     operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>( this );
     }
 
     operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>( this );
     }
 
     bool operator==( PhysicalDeviceFragmentDensityMapFeaturesEXT const& rhs ) const
@@ -20946,12 +35839,12 @@ public:
   {
     operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>( this );
     }
 
     operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>( this );
     }
 
     bool operator==( PhysicalDeviceFragmentDensityMapPropertiesEXT const& rhs ) const
@@ -20979,2597 +35872,233 @@ public:
   };
   static_assert( sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), "struct and wrapper have different size!" );
 
-  struct RenderPassFragmentDensityMapCreateInfoEXT
+  struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
   {
-    RenderPassFragmentDensityMapCreateInfoEXT( AttachmentReference fragmentDensityMapAttachment_ = AttachmentReference() )
-      : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ )
+    PhysicalDeviceFragmentShaderBarycentricFeaturesNV( Bool32 fragmentShaderBarycentric_ = 0 )
+      : fragmentShaderBarycentric( fragmentShaderBarycentric_ )
+    {}
+
+    PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) );
     }
 
-    RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs )
+    PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) );
-    }
-
-    RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) );
       return *this;
     }
-    RenderPassFragmentDensityMapCreateInfoEXT& setPNext( const void* pNext_ )
+
+    PhysicalDeviceFragmentShaderBarycentricFeaturesNV & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    RenderPassFragmentDensityMapCreateInfoEXT& setFragmentDensityMapAttachment( AttachmentReference fragmentDensityMapAttachment_ )
+    PhysicalDeviceFragmentShaderBarycentricFeaturesNV & setFragmentShaderBarycentric( Bool32 fragmentShaderBarycentric_ )
     {
-      fragmentDensityMapAttachment = fragmentDensityMapAttachment_;
+      fragmentShaderBarycentric = fragmentShaderBarycentric_;
       return *this;
     }
 
-    operator VkRenderPassFragmentDensityMapCreateInfoEXT const&() const
+    operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const&() const
     {
-      return *reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>( this );
     }
 
-    operator VkRenderPassFragmentDensityMapCreateInfoEXT &()
+    operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV &()
     {
-      return *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>( this );
     }
 
-    bool operator==( RenderPassFragmentDensityMapCreateInfoEXT const& rhs ) const
+    bool operator==( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment );
+          && ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric );
     }
 
-    bool operator!=( RenderPassFragmentDensityMapCreateInfoEXT const& rhs ) const
+    bool operator!=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    AttachmentReference fragmentDensityMapAttachment;
-  };
-  static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceScalarBlockLayoutFeaturesEXT
-  {
-    PhysicalDeviceScalarBlockLayoutFeaturesEXT( Bool32 scalarBlockLayout_ = 0 )
-      : scalarBlockLayout( scalarBlockLayout_ )
-    {
-    }
-
-    PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) );
-    }
-
-    PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) );
-      return *this;
-    }
-    PhysicalDeviceScalarBlockLayoutFeaturesEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceScalarBlockLayoutFeaturesEXT& setScalarBlockLayout( Bool32 scalarBlockLayout_ )
-    {
-      scalarBlockLayout = scalarBlockLayout_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeaturesEXT*>(this);
-    }
-
-    operator VkPhysicalDeviceScalarBlockLayoutFeaturesEXT &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceScalarBlockLayoutFeaturesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( scalarBlockLayout == rhs.scalarBlockLayout );
-    }
-
-    bool operator!=( PhysicalDeviceScalarBlockLayoutFeaturesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT;
+    StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV;
 
   public:
     void* pNext = nullptr;
-    Bool32 scalarBlockLayout;
+    Bool32 fragmentShaderBarycentric;
   };
-  static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "struct and wrapper have different size!" );
 
-  enum class SubpassContents
+  struct PhysicalDeviceGroupProperties
   {
-    eInline = VK_SUBPASS_CONTENTS_INLINE,
-    eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
-  };
-
-  struct SubpassBeginInfoKHR
-  {
-    SubpassBeginInfoKHR( SubpassContents contents_ = SubpassContents::eInline )
-      : contents( contents_ )
+    operator VkPhysicalDeviceGroupProperties const&() const
     {
+      return *reinterpret_cast<const VkPhysicalDeviceGroupProperties*>( this );
     }
 
-    SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs )
+    operator VkPhysicalDeviceGroupProperties &()
     {
-      memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
+      return *reinterpret_cast<VkPhysicalDeviceGroupProperties*>( this );
     }
 
-    SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
-      return *this;
-    }
-    SubpassBeginInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SubpassBeginInfoKHR& setContents( SubpassContents contents_ )
-    {
-      contents = contents_;
-      return *this;
-    }
-
-    operator VkSubpassBeginInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkSubpassBeginInfoKHR*>(this);
-    }
-
-    operator VkSubpassBeginInfoKHR &()
-    {
-      return *reinterpret_cast<VkSubpassBeginInfoKHR*>(this);
-    }
-
-    bool operator==( SubpassBeginInfoKHR const& rhs ) const
+    bool operator==( PhysicalDeviceGroupProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( contents == rhs.contents );
+          && ( physicalDeviceCount == rhs.physicalDeviceCount )
+          && ( memcmp( physicalDevices, rhs.physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof( PhysicalDevice ) ) == 0 )
+          && ( subsetAllocation == rhs.subsetAllocation );
     }
 
-    bool operator!=( SubpassBeginInfoKHR const& rhs ) const
+    bool operator!=( PhysicalDeviceGroupProperties const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eSubpassBeginInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    SubpassContents contents;
-  };
-  static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "struct and wrapper have different size!" );
-
-  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 )
-      : waitSemaphoreCount( waitSemaphoreCount_ )
-      , pWaitSemaphores( pWaitSemaphores_ )
-      , swapchainCount( swapchainCount_ )
-      , pSwapchains( pSwapchains_ )
-      , pImageIndices( pImageIndices_ )
-      , pResults( pResults_ )
-    {
-    }
-
-    PresentInfoKHR( VkPresentInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
-    }
-
-    PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
-      return *this;
-    }
-    PresentInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
-    {
-      waitSemaphoreCount = waitSemaphoreCount_;
-      return *this;
-    }
-
-    PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
-    {
-      pWaitSemaphores = pWaitSemaphores_;
-      return *this;
-    }
-
-    PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ )
-    {
-      swapchainCount = swapchainCount_;
-      return *this;
-    }
-
-    PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ )
-    {
-      pSwapchains = pSwapchains_;
-      return *this;
-    }
-
-    PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ )
-    {
-      pImageIndices = pImageIndices_;
-      return *this;
-    }
-
-    PresentInfoKHR& setPResults( Result* pResults_ )
-    {
-      pResults = pResults_;
-      return *this;
-    }
-
-    operator VkPresentInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkPresentInfoKHR*>(this);
-    }
-
-    operator VkPresentInfoKHR &()
-    {
-      return *reinterpret_cast<VkPresentInfoKHR*>(this);
-    }
-
-    bool operator==( PresentInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
-          && ( pWaitSemaphores == rhs.pWaitSemaphores )
-          && ( swapchainCount == rhs.swapchainCount )
-          && ( pSwapchains == rhs.pSwapchains )
-          && ( pImageIndices == rhs.pImageIndices )
-          && ( pResults == rhs.pResults );
-    }
-
-    bool operator!=( PresentInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePresentInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreCount;
-    const Semaphore* pWaitSemaphores;
-    uint32_t swapchainCount;
-    const SwapchainKHR* pSwapchains;
-    const uint32_t* pImageIndices;
-    Result* pResults;
-  };
-  static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class DynamicState
-  {
-    eViewport = VK_DYNAMIC_STATE_VIEWPORT,
-    eScissor = VK_DYNAMIC_STATE_SCISSOR,
-    eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
-    eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
-    eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
-    eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
-    eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
-    eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
-    eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
-    eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV,
-    eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT,
-    eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT,
-    eViewportShadingRatePaletteNV = VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV,
-    eViewportCoarseSampleOrderNV = VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV,
-    eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV
-  };
-
-  struct PipelineDynamicStateCreateInfo
-  {
-    PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(),
-                                    uint32_t dynamicStateCount_ = 0,
-                                    const DynamicState* pDynamicStates_ = nullptr )
-      : flags( flags_ )
-      , dynamicStateCount( dynamicStateCount_ )
-      , pDynamicStates( pDynamicStates_ )
-    {
-    }
-
-    PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
-    }
-
-    PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
-      return *this;
-    }
-    PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ )
-    {
-      dynamicStateCount = dynamicStateCount_;
-      return *this;
-    }
-
-    PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ )
-    {
-      pDynamicStates = pDynamicStates_;
-      return *this;
-    }
-
-    operator VkPipelineDynamicStateCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(this);
-    }
-
-    operator VkPipelineDynamicStateCreateInfo &()
-    {
-      return *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( dynamicStateCount == rhs.dynamicStateCount )
-          && ( pDynamicStates == rhs.pDynamicStates );
-    }
-
-    bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineDynamicStateCreateFlags flags;
-    uint32_t dynamicStateCount;
-    const DynamicState* pDynamicStates;
-  };
-  static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class DescriptorUpdateTemplateType
-  {
-    eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
-    eDescriptorSetKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
-    ePushDescriptorsKHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
-  };
-
-  struct DescriptorUpdateTemplateCreateInfo
-  {
-    DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_ = DescriptorUpdateTemplateCreateFlags(),
-                                        uint32_t descriptorUpdateEntryCount_ = 0,
-                                        const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr,
-                                        DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet,
-                                        DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(),
-                                        PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
-                                        PipelineLayout pipelineLayout_ = PipelineLayout(),
-                                        uint32_t set_ = 0 )
-      : flags( flags_ )
-      , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
-      , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
-      , templateType( templateType_ )
-      , descriptorSetLayout( descriptorSetLayout_ )
-      , pipelineBindPoint( pipelineBindPoint_ )
-      , pipelineLayout( pipelineLayout_ )
-      , set( set_ )
-    {
-    }
-
-    DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
-    }
-
-    DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
-      return *this;
-    }
-    DescriptorUpdateTemplateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfo& setFlags( DescriptorUpdateTemplateCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfo& setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ )
-    {
-      descriptorUpdateEntryCount = descriptorUpdateEntryCount_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfo& setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ )
-    {
-      pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfo& setTemplateType( DescriptorUpdateTemplateType templateType_ )
-    {
-      templateType = templateType_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfo& setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ )
-    {
-      descriptorSetLayout = descriptorSetLayout_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfo& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
-    {
-      pipelineBindPoint = pipelineBindPoint_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfo& setPipelineLayout( PipelineLayout pipelineLayout_ )
-    {
-      pipelineLayout = pipelineLayout_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfo& setSet( uint32_t set_ )
-    {
-      set = set_;
-      return *this;
-    }
-
-    operator VkDescriptorUpdateTemplateCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>(this);
-    }
-
-    operator VkDescriptorUpdateTemplateCreateInfo &()
-    {
-      return *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>(this);
-    }
-
-    bool operator==( DescriptorUpdateTemplateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount )
-          && ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries )
-          && ( templateType == rhs.templateType )
-          && ( descriptorSetLayout == rhs.descriptorSetLayout )
-          && ( pipelineBindPoint == rhs.pipelineBindPoint )
-          && ( pipelineLayout == rhs.pipelineLayout )
-          && ( set == rhs.set );
-    }
-
-    bool operator!=( DescriptorUpdateTemplateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorUpdateTemplateCreateFlags flags;
-    uint32_t descriptorUpdateEntryCount;
-    const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;
-    DescriptorUpdateTemplateType templateType;
-    DescriptorSetLayout descriptorSetLayout;
-    PipelineBindPoint pipelineBindPoint;
-    PipelineLayout pipelineLayout;
-    uint32_t set;
-  };
-  static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" );
-
-  using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
-
-  enum class ObjectType
-  {
-    eUnknown = VK_OBJECT_TYPE_UNKNOWN,
-    eInstance = VK_OBJECT_TYPE_INSTANCE,
-    ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE,
-    eDevice = VK_OBJECT_TYPE_DEVICE,
-    eQueue = VK_OBJECT_TYPE_QUEUE,
-    eSemaphore = VK_OBJECT_TYPE_SEMAPHORE,
-    eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER,
-    eFence = VK_OBJECT_TYPE_FENCE,
-    eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY,
-    eBuffer = VK_OBJECT_TYPE_BUFFER,
-    eImage = VK_OBJECT_TYPE_IMAGE,
-    eEvent = VK_OBJECT_TYPE_EVENT,
-    eQueryPool = VK_OBJECT_TYPE_QUERY_POOL,
-    eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW,
-    eImageView = VK_OBJECT_TYPE_IMAGE_VIEW,
-    eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE,
-    ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE,
-    ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT,
-    eRenderPass = VK_OBJECT_TYPE_RENDER_PASS,
-    ePipeline = VK_OBJECT_TYPE_PIPELINE,
-    eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
-    eSampler = VK_OBJECT_TYPE_SAMPLER,
-    eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL,
-    eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET,
-    eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER,
-    eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL,
-    eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
-    eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
-    eDescriptorUpdateTemplate = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
-    eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
-    eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR,
-    eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR,
-    eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR,
-    eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR,
-    eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT,
-    eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX,
-    eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX,
-    eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT,
-    eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT,
-    eAccelerationStructureNV = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV
-  };
-
-  struct DebugUtilsObjectNameInfoEXT
-  {
-    DebugUtilsObjectNameInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
-                                 uint64_t objectHandle_ = 0,
-                                 const char* pObjectName_ = nullptr )
-      : objectType( objectType_ )
-      , objectHandle( objectHandle_ )
-      , pObjectName( pObjectName_ )
-    {
-    }
-
-    DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
-    }
-
-    DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
-      return *this;
-    }
-    DebugUtilsObjectNameInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DebugUtilsObjectNameInfoEXT& setObjectType( ObjectType objectType_ )
-    {
-      objectType = objectType_;
-      return *this;
-    }
-
-    DebugUtilsObjectNameInfoEXT& setObjectHandle( uint64_t objectHandle_ )
-    {
-      objectHandle = objectHandle_;
-      return *this;
-    }
-
-    DebugUtilsObjectNameInfoEXT& setPObjectName( const char* pObjectName_ )
-    {
-      pObjectName = pObjectName_;
-      return *this;
-    }
-
-    operator VkDebugUtilsObjectNameInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(this);
-    }
-
-    operator VkDebugUtilsObjectNameInfoEXT &()
-    {
-      return *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(this);
-    }
-
-    bool operator==( DebugUtilsObjectNameInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( objectType == rhs.objectType )
-          && ( objectHandle == rhs.objectHandle )
-          && ( pObjectName == rhs.pObjectName );
-    }
-
-    bool operator!=( DebugUtilsObjectNameInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ObjectType objectType;
-    uint64_t objectHandle;
-    const char* pObjectName;
-  };
-  static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" );
-
-  struct DebugUtilsObjectTagInfoEXT
-  {
-    DebugUtilsObjectTagInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
-                                uint64_t objectHandle_ = 0,
-                                uint64_t tagName_ = 0,
-                                size_t tagSize_ = 0,
-                                const void* pTag_ = nullptr )
-      : objectType( objectType_ )
-      , objectHandle( objectHandle_ )
-      , tagName( tagName_ )
-      , tagSize( tagSize_ )
-      , pTag( pTag_ )
-    {
-    }
-
-    DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
-    }
-
-    DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
-      return *this;
-    }
-    DebugUtilsObjectTagInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DebugUtilsObjectTagInfoEXT& setObjectType( ObjectType objectType_ )
-    {
-      objectType = objectType_;
-      return *this;
-    }
-
-    DebugUtilsObjectTagInfoEXT& setObjectHandle( uint64_t objectHandle_ )
-    {
-      objectHandle = objectHandle_;
-      return *this;
-    }
-
-    DebugUtilsObjectTagInfoEXT& setTagName( uint64_t tagName_ )
-    {
-      tagName = tagName_;
-      return *this;
-    }
-
-    DebugUtilsObjectTagInfoEXT& setTagSize( size_t tagSize_ )
-    {
-      tagSize = tagSize_;
-      return *this;
-    }
-
-    DebugUtilsObjectTagInfoEXT& setPTag( const void* pTag_ )
-    {
-      pTag = pTag_;
-      return *this;
-    }
-
-    operator VkDebugUtilsObjectTagInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>(this);
-    }
-
-    operator VkDebugUtilsObjectTagInfoEXT &()
-    {
-      return *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>(this);
-    }
-
-    bool operator==( DebugUtilsObjectTagInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( objectType == rhs.objectType )
-          && ( objectHandle == rhs.objectHandle )
-          && ( tagName == rhs.tagName )
-          && ( tagSize == rhs.tagSize )
-          && ( pTag == rhs.pTag );
-    }
-
-    bool operator!=( DebugUtilsObjectTagInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ObjectType objectType;
-    uint64_t objectHandle;
-    uint64_t tagName;
-    size_t tagSize;
-    const void* pTag;
-  };
-  static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "struct and wrapper have different size!" );
-
-  struct DebugUtilsMessengerCallbackDataEXT
-  {
-    DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_ = DebugUtilsMessengerCallbackDataFlagsEXT(),
-                                        const char* pMessageIdName_ = nullptr,
-                                        int32_t messageIdNumber_ = 0,
-                                        const char* pMessage_ = nullptr,
-                                        uint32_t queueLabelCount_ = 0,
-                                        DebugUtilsLabelEXT* pQueueLabels_ = nullptr,
-                                        uint32_t cmdBufLabelCount_ = 0,
-                                        DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr,
-                                        uint32_t objectCount_ = 0,
-                                        DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr )
-      : flags( flags_ )
-      , pMessageIdName( pMessageIdName_ )
-      , messageIdNumber( messageIdNumber_ )
-      , pMessage( pMessage_ )
-      , queueLabelCount( queueLabelCount_ )
-      , pQueueLabels( pQueueLabels_ )
-      , cmdBufLabelCount( cmdBufLabelCount_ )
-      , pCmdBufLabels( pCmdBufLabels_ )
-      , objectCount( objectCount_ )
-      , pObjects( pObjects_ )
-    {
-    }
-
-    DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) );
-    }
-
-    DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) );
-      return *this;
-    }
-    DebugUtilsMessengerCallbackDataEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCallbackDataEXT& setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCallbackDataEXT& setPMessageIdName( const char* pMessageIdName_ )
-    {
-      pMessageIdName = pMessageIdName_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCallbackDataEXT& setMessageIdNumber( int32_t messageIdNumber_ )
-    {
-      messageIdNumber = messageIdNumber_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCallbackDataEXT& setPMessage( const char* pMessage_ )
-    {
-      pMessage = pMessage_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCallbackDataEXT& setQueueLabelCount( uint32_t queueLabelCount_ )
-    {
-      queueLabelCount = queueLabelCount_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCallbackDataEXT& setPQueueLabels( DebugUtilsLabelEXT* pQueueLabels_ )
-    {
-      pQueueLabels = pQueueLabels_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCallbackDataEXT& setCmdBufLabelCount( uint32_t cmdBufLabelCount_ )
-    {
-      cmdBufLabelCount = cmdBufLabelCount_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCallbackDataEXT& setPCmdBufLabels( DebugUtilsLabelEXT* pCmdBufLabels_ )
-    {
-      pCmdBufLabels = pCmdBufLabels_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCallbackDataEXT& setObjectCount( uint32_t objectCount_ )
-    {
-      objectCount = objectCount_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCallbackDataEXT& setPObjects( DebugUtilsObjectNameInfoEXT* pObjects_ )
-    {
-      pObjects = pObjects_;
-      return *this;
-    }
-
-    operator VkDebugUtilsMessengerCallbackDataEXT const&() const
-    {
-      return *reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>(this);
-    }
-
-    operator VkDebugUtilsMessengerCallbackDataEXT &()
-    {
-      return *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>(this);
-    }
-
-    bool operator==( DebugUtilsMessengerCallbackDataEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( pMessageIdName == rhs.pMessageIdName )
-          && ( messageIdNumber == rhs.messageIdNumber )
-          && ( pMessage == rhs.pMessage )
-          && ( queueLabelCount == rhs.queueLabelCount )
-          && ( pQueueLabels == rhs.pQueueLabels )
-          && ( cmdBufLabelCount == rhs.cmdBufLabelCount )
-          && ( pCmdBufLabels == rhs.pCmdBufLabels )
-          && ( objectCount == rhs.objectCount )
-          && ( pObjects == rhs.pObjects );
-    }
-
-    bool operator!=( DebugUtilsMessengerCallbackDataEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DebugUtilsMessengerCallbackDataFlagsEXT flags;
-    const char* pMessageIdName;
-    int32_t messageIdNumber;
-    const char* pMessage;
-    uint32_t queueLabelCount;
-    DebugUtilsLabelEXT* pQueueLabels;
-    uint32_t cmdBufLabelCount;
-    DebugUtilsLabelEXT* pCmdBufLabels;
-    uint32_t objectCount;
-    DebugUtilsObjectNameInfoEXT* pObjects;
-  };
-  static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "struct and wrapper have different size!" );
-
-  enum class QueueFlagBits
-  {
-    eGraphics = VK_QUEUE_GRAPHICS_BIT,
-    eCompute = VK_QUEUE_COMPUTE_BIT,
-    eTransfer = VK_QUEUE_TRANSFER_BIT,
-    eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT,
-    eProtected = VK_QUEUE_PROTECTED_BIT
-  };
-
-  using QueueFlags = Flags<QueueFlagBits, VkQueueFlags>;
-
-  VULKAN_HPP_INLINE QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 )
-  {
-    return QueueFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE QueueFlags operator~( QueueFlagBits bits )
-  {
-    return ~( QueueFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<QueueFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(QueueFlagBits::eGraphics) | VkFlags(QueueFlagBits::eCompute) | VkFlags(QueueFlagBits::eTransfer) | VkFlags(QueueFlagBits::eSparseBinding) | VkFlags(QueueFlagBits::eProtected)
-    };
-  };
-
-  struct QueueFamilyProperties
-  {
-    operator VkQueueFamilyProperties const&() const
-    {
-      return *reinterpret_cast<const VkQueueFamilyProperties*>(this);
-    }
-
-    operator VkQueueFamilyProperties &()
-    {
-      return *reinterpret_cast<VkQueueFamilyProperties*>(this);
-    }
-
-    bool operator==( QueueFamilyProperties const& rhs ) const
-    {
-      return ( queueFlags == rhs.queueFlags )
-          && ( queueCount == rhs.queueCount )
-          && ( timestampValidBits == rhs.timestampValidBits )
-          && ( minImageTransferGranularity == rhs.minImageTransferGranularity );
-    }
-
-    bool operator!=( QueueFamilyProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    QueueFlags queueFlags;
-    uint32_t queueCount;
-    uint32_t timestampValidBits;
-    Extent3D minImageTransferGranularity;
-  };
-  static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" );
-
-  struct QueueFamilyProperties2
-  {
-    operator VkQueueFamilyProperties2 const&() const
-    {
-      return *reinterpret_cast<const VkQueueFamilyProperties2*>(this);
-    }
-
-    operator VkQueueFamilyProperties2 &()
-    {
-      return *reinterpret_cast<VkQueueFamilyProperties2*>(this);
-    }
-
-    bool operator==( QueueFamilyProperties2 const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( queueFamilyProperties == rhs.queueFamilyProperties );
-    }
-
-    bool operator!=( QueueFamilyProperties2 const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eQueueFamilyProperties2;
+    StructureType sType = StructureType::ePhysicalDeviceGroupProperties;
 
   public:
     void* pNext = nullptr;
-    QueueFamilyProperties queueFamilyProperties;
+    uint32_t physicalDeviceCount;
+    PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
+    Bool32 subsetAllocation;
   };
-  static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "struct and wrapper have different size!" );
 
-  using QueueFamilyProperties2KHR = QueueFamilyProperties2;
-
-  enum class DeviceQueueCreateFlagBits
+  struct PhysicalDeviceIDProperties
   {
-    eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
-  };
-
-  using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits, VkDeviceQueueCreateFlags>;
-
-  VULKAN_HPP_INLINE DeviceQueueCreateFlags operator|( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 )
-  {
-    return DeviceQueueCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DeviceQueueCreateFlags operator~( DeviceQueueCreateFlagBits bits )
-  {
-    return ~( DeviceQueueCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<DeviceQueueCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(DeviceQueueCreateFlagBits::eProtected)
-    };
-  };
-
-  struct DeviceQueueCreateInfo
-  {
-    DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(),
-                           uint32_t queueFamilyIndex_ = 0,
-                           uint32_t queueCount_ = 0,
-                           const float* pQueuePriorities_ = nullptr )
-      : flags( flags_ )
-      , queueFamilyIndex( queueFamilyIndex_ )
-      , queueCount( queueCount_ )
-      , pQueuePriorities( pQueuePriorities_ )
+    operator VkPhysicalDeviceIDProperties const&() const
     {
+      return *reinterpret_cast<const VkPhysicalDeviceIDProperties*>( this );
     }
 
-    DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs )
+    operator VkPhysicalDeviceIDProperties &()
     {
-      memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
+      return *reinterpret_cast<VkPhysicalDeviceIDProperties*>( this );
     }
 
-    DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
-      return *this;
-    }
-    DeviceQueueCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceQueueCreateInfo& setFlags( DeviceQueueCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DeviceQueueCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
-    {
-      queueFamilyIndex = queueFamilyIndex_;
-      return *this;
-    }
-
-    DeviceQueueCreateInfo& setQueueCount( uint32_t queueCount_ )
-    {
-      queueCount = queueCount_;
-      return *this;
-    }
-
-    DeviceQueueCreateInfo& setPQueuePriorities( const float* pQueuePriorities_ )
-    {
-      pQueuePriorities = pQueuePriorities_;
-      return *this;
-    }
-
-    operator VkDeviceQueueCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkDeviceQueueCreateInfo*>(this);
-    }
-
-    operator VkDeviceQueueCreateInfo &()
-    {
-      return *reinterpret_cast<VkDeviceQueueCreateInfo*>(this);
-    }
-
-    bool operator==( DeviceQueueCreateInfo const& rhs ) const
+    bool operator==( PhysicalDeviceIDProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( queueFamilyIndex == rhs.queueFamilyIndex )
-          && ( queueCount == rhs.queueCount )
-          && ( pQueuePriorities == rhs.pQueuePriorities );
+          && ( memcmp( deviceUUID, rhs.deviceUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
+          && ( memcmp( driverUUID, rhs.driverUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
+          && ( memcmp( deviceLUID, rhs.deviceLUID, VK_LUID_SIZE * sizeof( uint8_t ) ) == 0 )
+          && ( deviceNodeMask == rhs.deviceNodeMask )
+          && ( deviceLUIDValid == rhs.deviceLUIDValid );
     }
 
-    bool operator!=( DeviceQueueCreateInfo const& rhs ) const
+    bool operator!=( PhysicalDeviceIDProperties const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eDeviceQueueCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceQueueCreateFlags flags;
-    uint32_t queueFamilyIndex;
-    uint32_t queueCount;
-    const float* pQueuePriorities;
-  };
-  static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" );
-
-  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 )
-      : flags( flags_ )
-      , queueCreateInfoCount( queueCreateInfoCount_ )
-      , pQueueCreateInfos( pQueueCreateInfos_ )
-      , enabledLayerCount( enabledLayerCount_ )
-      , ppEnabledLayerNames( ppEnabledLayerNames_ )
-      , enabledExtensionCount( enabledExtensionCount_ )
-      , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
-      , pEnabledFeatures( pEnabledFeatures_ )
-    {
-    }
-
-    DeviceCreateInfo( VkDeviceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
-    }
-
-    DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
-      return *this;
-    }
-    DeviceCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setFlags( DeviceCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setQueueCreateInfoCount( uint32_t queueCreateInfoCount_ )
-    {
-      queueCreateInfoCount = queueCreateInfoCount_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setPQueueCreateInfos( const DeviceQueueCreateInfo* pQueueCreateInfos_ )
-    {
-      pQueueCreateInfos = pQueueCreateInfos_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ )
-    {
-      enabledLayerCount = enabledLayerCount_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ )
-    {
-      ppEnabledLayerNames = ppEnabledLayerNames_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ )
-    {
-      enabledExtensionCount = enabledExtensionCount_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ )
-    {
-      ppEnabledExtensionNames = ppEnabledExtensionNames_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setPEnabledFeatures( const PhysicalDeviceFeatures* pEnabledFeatures_ )
-    {
-      pEnabledFeatures = pEnabledFeatures_;
-      return *this;
-    }
-
-    operator VkDeviceCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkDeviceCreateInfo*>(this);
-    }
-
-    operator VkDeviceCreateInfo &()
-    {
-      return *reinterpret_cast<VkDeviceCreateInfo*>(this);
-    }
-
-    bool operator==( DeviceCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( queueCreateInfoCount == rhs.queueCreateInfoCount )
-          && ( pQueueCreateInfos == rhs.pQueueCreateInfos )
-          && ( enabledLayerCount == rhs.enabledLayerCount )
-          && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames )
-          && ( enabledExtensionCount == rhs.enabledExtensionCount )
-          && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames )
-          && ( pEnabledFeatures == rhs.pEnabledFeatures );
-    }
-
-    bool operator!=( DeviceCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceCreateFlags flags;
-    uint32_t queueCreateInfoCount;
-    const DeviceQueueCreateInfo* pQueueCreateInfos;
-    uint32_t enabledLayerCount;
-    const char* const* ppEnabledLayerNames;
-    uint32_t enabledExtensionCount;
-    const char* const* ppEnabledExtensionNames;
-    const PhysicalDeviceFeatures* pEnabledFeatures;
-  };
-  static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" );
-
-  struct DeviceQueueInfo2
-  {
-    DeviceQueueInfo2( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(),
-                      uint32_t queueFamilyIndex_ = 0,
-                      uint32_t queueIndex_ = 0 )
-      : flags( flags_ )
-      , queueFamilyIndex( queueFamilyIndex_ )
-      , queueIndex( queueIndex_ )
-    {
-    }
-
-    DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) );
-    }
-
-    DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) );
-      return *this;
-    }
-    DeviceQueueInfo2& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceQueueInfo2& setFlags( DeviceQueueCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DeviceQueueInfo2& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
-    {
-      queueFamilyIndex = queueFamilyIndex_;
-      return *this;
-    }
-
-    DeviceQueueInfo2& setQueueIndex( uint32_t queueIndex_ )
-    {
-      queueIndex = queueIndex_;
-      return *this;
-    }
-
-    operator VkDeviceQueueInfo2 const&() const
-    {
-      return *reinterpret_cast<const VkDeviceQueueInfo2*>(this);
-    }
-
-    operator VkDeviceQueueInfo2 &()
-    {
-      return *reinterpret_cast<VkDeviceQueueInfo2*>(this);
-    }
-
-    bool operator==( DeviceQueueInfo2 const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( queueFamilyIndex == rhs.queueFamilyIndex )
-          && ( queueIndex == rhs.queueIndex );
-    }
-
-    bool operator!=( DeviceQueueInfo2 const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceQueueInfo2;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceQueueCreateFlags flags;
-    uint32_t queueFamilyIndex;
-    uint32_t queueIndex;
-  };
-  static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" );
-
-  enum class MemoryPropertyFlagBits
-  {
-    eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
-    eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-    eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
-    eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
-    eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT,
-    eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT
-  };
-
-  using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits, VkMemoryPropertyFlags>;
-
-  VULKAN_HPP_INLINE MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
-  {
-    return MemoryPropertyFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits )
-  {
-    return ~( MemoryPropertyFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<MemoryPropertyFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated) | VkFlags(MemoryPropertyFlagBits::eProtected)
-    };
-  };
-
-  struct MemoryType
-  {
-    operator VkMemoryType const&() const
-    {
-      return *reinterpret_cast<const VkMemoryType*>(this);
-    }
-
-    operator VkMemoryType &()
-    {
-      return *reinterpret_cast<VkMemoryType*>(this);
-    }
-
-    bool operator==( MemoryType const& rhs ) const
-    {
-      return ( propertyFlags == rhs.propertyFlags )
-          && ( heapIndex == rhs.heapIndex );
-    }
-
-    bool operator!=( MemoryType const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    MemoryPropertyFlags propertyFlags;
-    uint32_t heapIndex;
-  };
-  static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" );
-
-  enum class MemoryHeapFlagBits
-  {
-    eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
-    eMultiInstance = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
-    eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT
-  };
-
-  using MemoryHeapFlags = Flags<MemoryHeapFlagBits, VkMemoryHeapFlags>;
-
-  VULKAN_HPP_INLINE MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
-  {
-    return MemoryHeapFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE MemoryHeapFlags operator~( MemoryHeapFlagBits bits )
-  {
-    return ~( MemoryHeapFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<MemoryHeapFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(MemoryHeapFlagBits::eDeviceLocal) | VkFlags(MemoryHeapFlagBits::eMultiInstance)
-    };
-  };
-
-  struct MemoryHeap
-  {
-    operator VkMemoryHeap const&() const
-    {
-      return *reinterpret_cast<const VkMemoryHeap*>(this);
-    }
-
-    operator VkMemoryHeap &()
-    {
-      return *reinterpret_cast<VkMemoryHeap*>(this);
-    }
-
-    bool operator==( MemoryHeap const& rhs ) const
-    {
-      return ( size == rhs.size )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( MemoryHeap const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize size;
-    MemoryHeapFlags flags;
-  };
-  static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceMemoryProperties
-  {
-    operator VkPhysicalDeviceMemoryProperties const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>(this);
-    }
-
-    operator VkPhysicalDeviceMemoryProperties &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceMemoryProperties*>(this);
-    }
-
-    bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const
-    {
-      return ( memoryTypeCount == rhs.memoryTypeCount )
-          && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 )
-          && ( memoryHeapCount == rhs.memoryHeapCount )
-          && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 );
-    }
-
-    bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t memoryTypeCount;
-    MemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
-    uint32_t memoryHeapCount;
-    MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
-  };
-  static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceMemoryProperties2
-  {
-    operator VkPhysicalDeviceMemoryProperties2 const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2*>(this);
-    }
-
-    operator VkPhysicalDeviceMemoryProperties2 &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>(this);
-    }
-
-    bool operator==( PhysicalDeviceMemoryProperties2 const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memoryProperties == rhs.memoryProperties );
-    }
-
-    bool operator!=( PhysicalDeviceMemoryProperties2 const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2;
+    StructureType sType = StructureType::ePhysicalDeviceIdProperties;
 
   public:
     void* pNext = nullptr;
-    PhysicalDeviceMemoryProperties memoryProperties;
+    uint8_t deviceUUID[VK_UUID_SIZE];
+    uint8_t driverUUID[VK_UUID_SIZE];
+    uint8_t deviceLUID[VK_LUID_SIZE];
+    uint32_t deviceNodeMask;
+    Bool32 deviceLUIDValid;
   };
-  static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "struct and wrapper have different size!" );
 
-  using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
-
-  enum class AccessFlagBits
+  struct PhysicalDeviceImageDrmFormatModifierInfoEXT
   {
-    eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
-    eIndexRead = VK_ACCESS_INDEX_READ_BIT,
-    eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
-    eUniformRead = VK_ACCESS_UNIFORM_READ_BIT,
-    eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
-    eShaderRead = VK_ACCESS_SHADER_READ_BIT,
-    eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT,
-    eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
-    eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-    eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
-    eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
-    eTransferRead = VK_ACCESS_TRANSFER_READ_BIT,
-    eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT,
-    eHostRead = VK_ACCESS_HOST_READ_BIT,
-    eHostWrite = VK_ACCESS_HOST_WRITE_BIT,
-    eMemoryRead = VK_ACCESS_MEMORY_READ_BIT,
-    eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT,
-    eTransformFeedbackWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
-    eTransformFeedbackCounterReadEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
-    eTransformFeedbackCounterWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
-    eConditionalRenderingReadEXT = VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT,
-    eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX,
-    eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX,
-    eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT,
-    eShadingRateImageReadNV = VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV,
-    eAccelerationStructureReadNV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV,
-    eAccelerationStructureWriteNV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV,
-    eFragmentDensityMapReadEXT = VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT
-  };
-
-  using AccessFlags = Flags<AccessFlagBits, VkAccessFlags>;
-
-  VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 )
-  {
-    return AccessFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits )
-  {
-    return ~( AccessFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<AccessFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eTransformFeedbackWriteEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterReadEXT) | VkFlags(AccessFlagBits::eTransformFeedbackCounterWriteEXT) | VkFlags(AccessFlagBits::eConditionalRenderingReadEXT) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) | VkFlags(AccessFlagBits::eShadingRateImageReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureReadNV) | VkFlags(AccessFlagBits::eAccelerationStructureWriteNV) | VkFlags(AccessFlagBits::eFragmentDensityMapReadEXT)
-    };
-  };
-
-  struct MemoryBarrier
-  {
-    MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(),
-                   AccessFlags dstAccessMask_ = AccessFlags() )
-      : srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
-    {
-    }
-
-    MemoryBarrier( VkMemoryBarrier const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryBarrier ) );
-    }
-
-    MemoryBarrier& operator=( VkMemoryBarrier const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryBarrier ) );
-      return *this;
-    }
-    MemoryBarrier& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
-    {
-      srcAccessMask = srcAccessMask_;
-      return *this;
-    }
-
-    MemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
-    {
-      dstAccessMask = dstAccessMask_;
-      return *this;
-    }
-
-    operator VkMemoryBarrier const&() const
-    {
-      return *reinterpret_cast<const VkMemoryBarrier*>(this);
-    }
-
-    operator VkMemoryBarrier &()
-    {
-      return *reinterpret_cast<VkMemoryBarrier*>(this);
-    }
-
-    bool operator==( MemoryBarrier const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( srcAccessMask == rhs.srcAccessMask )
-          && ( dstAccessMask == rhs.dstAccessMask );
-    }
-
-    bool operator!=( MemoryBarrier const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryBarrier;
-
-  public:
-    const void* pNext = nullptr;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
-  };
-  static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" );
-
-  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 )
-      : srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
-      , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
-      , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
-      , buffer( buffer_ )
-      , offset( offset_ )
-      , size( size_ )
-    {
-    }
-
-    BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
-    }
-
-    BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
-      return *this;
-    }
-    BufferMemoryBarrier& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
-    {
-      srcAccessMask = srcAccessMask_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
-    {
-      dstAccessMask = dstAccessMask_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
-    {
-      srcQueueFamilyIndex = srcQueueFamilyIndex_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
-    {
-      dstQueueFamilyIndex = dstQueueFamilyIndex_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setOffset( DeviceSize offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setSize( DeviceSize size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    operator VkBufferMemoryBarrier const&() const
-    {
-      return *reinterpret_cast<const VkBufferMemoryBarrier*>(this);
-    }
-
-    operator VkBufferMemoryBarrier &()
-    {
-      return *reinterpret_cast<VkBufferMemoryBarrier*>(this);
-    }
-
-    bool operator==( BufferMemoryBarrier const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( srcAccessMask == rhs.srcAccessMask )
-          && ( dstAccessMask == rhs.dstAccessMask )
-          && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
-          && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
-          && ( buffer == rhs.buffer )
-          && ( offset == rhs.offset )
-          && ( size == rhs.size );
-    }
-
-    bool operator!=( BufferMemoryBarrier const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBufferMemoryBarrier;
-
-  public:
-    const void* pNext = nullptr;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
-    uint32_t srcQueueFamilyIndex;
-    uint32_t dstQueueFamilyIndex;
-    Buffer buffer;
-    DeviceSize offset;
-    DeviceSize size;
-  };
-  static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" );
-
-  enum class BufferUsageFlagBits
-  {
-    eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
-    eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-    eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
-    eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
-    eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
-    eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
-    eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
-    eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
-    eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
-    eTransformFeedbackBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT,
-    eTransformFeedbackCounterBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT,
-    eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT,
-    eRayTracingNV = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV
-  };
-
-  using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>;
-
-  VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
-  {
-    return BufferUsageFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits )
-  {
-    return ~( BufferUsageFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<BufferUsageFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) | VkFlags(BufferUsageFlagBits::eTransformFeedbackBufferEXT) | VkFlags(BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) | VkFlags(BufferUsageFlagBits::eConditionalRenderingEXT) | VkFlags(BufferUsageFlagBits::eRayTracingNV)
-    };
-  };
-
-  enum class BufferCreateFlagBits
-  {
-    eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
-    eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
-    eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
-    eProtected = VK_BUFFER_CREATE_PROTECTED_BIT
-  };
-
-  using BufferCreateFlags = Flags<BufferCreateFlagBits, VkBufferCreateFlags>;
-
-  VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
-  {
-    return BufferCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits )
-  {
-    return ~( BufferCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<BufferCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased) | VkFlags(BufferCreateFlagBits::eProtected)
-    };
-  };
-
-  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 )
-      : flags( flags_ )
-      , size( size_ )
-      , usage( usage_ )
+    PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0,
+                                                 SharingMode sharingMode_ = SharingMode::eExclusive,
+                                                 uint32_t queueFamilyIndexCount_ = 0,
+                                                 const uint32_t* pQueueFamilyIndices_ = nullptr )
+      : drmFormatModifier( drmFormatModifier_ )
       , sharingMode( sharingMode_ )
       , queueFamilyIndexCount( queueFamilyIndexCount_ )
       , pQueueFamilyIndices( pQueueFamilyIndices_ )
+    {}
+
+    PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) );
     }
 
-    BufferCreateInfo( VkBufferCreateInfo const & rhs )
+    PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
     {
-      memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
-    }
-
-    BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) );
       return *this;
     }
-    BufferCreateInfo& setPNext( const void* pNext_ )
+
+    PhysicalDeviceImageDrmFormatModifierInfoEXT & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    BufferCreateInfo& setFlags( BufferCreateFlags flags_ )
+    PhysicalDeviceImageDrmFormatModifierInfoEXT & setDrmFormatModifier( uint64_t drmFormatModifier_ )
     {
-      flags = flags_;
+      drmFormatModifier = drmFormatModifier_;
       return *this;
     }
 
-    BufferCreateInfo& setSize( DeviceSize size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    BufferCreateInfo& setUsage( BufferUsageFlags usage_ )
-    {
-      usage = usage_;
-      return *this;
-    }
-
-    BufferCreateInfo& setSharingMode( SharingMode sharingMode_ )
+    PhysicalDeviceImageDrmFormatModifierInfoEXT & setSharingMode( SharingMode sharingMode_ )
     {
       sharingMode = sharingMode_;
       return *this;
     }
 
-    BufferCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
+    PhysicalDeviceImageDrmFormatModifierInfoEXT & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
     {
       queueFamilyIndexCount = queueFamilyIndexCount_;
       return *this;
     }
 
-    BufferCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
+    PhysicalDeviceImageDrmFormatModifierInfoEXT & setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
     {
       pQueueFamilyIndices = pQueueFamilyIndices_;
       return *this;
     }
 
-    operator VkBufferCreateInfo const&() const
+    operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const&() const
     {
-      return *reinterpret_cast<const VkBufferCreateInfo*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>( this );
     }
 
-    operator VkBufferCreateInfo &()
+    operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT &()
     {
-      return *reinterpret_cast<VkBufferCreateInfo*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>( this );
     }
 
-    bool operator==( BufferCreateInfo const& rhs ) const
+    bool operator==( PhysicalDeviceImageDrmFormatModifierInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( size == rhs.size )
-          && ( usage == rhs.usage )
+          && ( drmFormatModifier == rhs.drmFormatModifier )
           && ( sharingMode == rhs.sharingMode )
           && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
           && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
     }
 
-    bool operator!=( BufferCreateInfo const& rhs ) const
+    bool operator!=( PhysicalDeviceImageDrmFormatModifierInfoEXT const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eBufferCreateInfo;
+    StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT;
 
   public:
     const void* pNext = nullptr;
-    BufferCreateFlags flags;
-    DeviceSize size;
-    BufferUsageFlags usage;
+    uint64_t drmFormatModifier;
     SharingMode sharingMode;
     uint32_t queueFamilyIndexCount;
     const uint32_t* pQueueFamilyIndices;
   };
-  static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class ShaderStageFlagBits
-  {
-    eVertex = VK_SHADER_STAGE_VERTEX_BIT,
-    eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
-    eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
-    eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT,
-    eFragment = VK_SHADER_STAGE_FRAGMENT_BIT,
-    eCompute = VK_SHADER_STAGE_COMPUTE_BIT,
-    eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS,
-    eAll = VK_SHADER_STAGE_ALL,
-    eRaygenNV = VK_SHADER_STAGE_RAYGEN_BIT_NV,
-    eAnyHitNV = VK_SHADER_STAGE_ANY_HIT_BIT_NV,
-    eClosestHitNV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV,
-    eMissNV = VK_SHADER_STAGE_MISS_BIT_NV,
-    eIntersectionNV = VK_SHADER_STAGE_INTERSECTION_BIT_NV,
-    eCallableNV = VK_SHADER_STAGE_CALLABLE_BIT_NV,
-    eTaskNV = VK_SHADER_STAGE_TASK_BIT_NV,
-    eMeshNV = VK_SHADER_STAGE_MESH_BIT_NV
-  };
-
-  using ShaderStageFlags = Flags<ShaderStageFlagBits, VkShaderStageFlags>;
-
-  VULKAN_HPP_INLINE ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
-  {
-    return ShaderStageFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ShaderStageFlags operator~( ShaderStageFlagBits bits )
-  {
-    return ~( ShaderStageFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ShaderStageFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll) | VkFlags(ShaderStageFlagBits::eRaygenNV) | VkFlags(ShaderStageFlagBits::eAnyHitNV) | VkFlags(ShaderStageFlagBits::eClosestHitNV) | VkFlags(ShaderStageFlagBits::eMissNV) | VkFlags(ShaderStageFlagBits::eIntersectionNV) | VkFlags(ShaderStageFlagBits::eCallableNV) | VkFlags(ShaderStageFlagBits::eTaskNV) | VkFlags(ShaderStageFlagBits::eMeshNV)
-    };
-  };
-
-  struct DescriptorSetLayoutBinding
-  {
-    DescriptorSetLayoutBinding( uint32_t binding_ = 0,
-                                DescriptorType descriptorType_ = DescriptorType::eSampler,
-                                uint32_t descriptorCount_ = 0,
-                                ShaderStageFlags stageFlags_ = ShaderStageFlags(),
-                                const Sampler* pImmutableSamplers_ = nullptr )
-      : binding( binding_ )
-      , descriptorType( descriptorType_ )
-      , descriptorCount( descriptorCount_ )
-      , stageFlags( stageFlags_ )
-      , pImmutableSamplers( pImmutableSamplers_ )
-    {
-    }
-
-    DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
-    }
-
-    DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
-      return *this;
-    }
-    DescriptorSetLayoutBinding& setBinding( uint32_t binding_ )
-    {
-      binding = binding_;
-      return *this;
-    }
-
-    DescriptorSetLayoutBinding& setDescriptorType( DescriptorType descriptorType_ )
-    {
-      descriptorType = descriptorType_;
-      return *this;
-    }
-
-    DescriptorSetLayoutBinding& setDescriptorCount( uint32_t descriptorCount_ )
-    {
-      descriptorCount = descriptorCount_;
-      return *this;
-    }
-
-    DescriptorSetLayoutBinding& setStageFlags( ShaderStageFlags stageFlags_ )
-    {
-      stageFlags = stageFlags_;
-      return *this;
-    }
-
-    DescriptorSetLayoutBinding& setPImmutableSamplers( const Sampler* pImmutableSamplers_ )
-    {
-      pImmutableSamplers = pImmutableSamplers_;
-      return *this;
-    }
-
-    operator VkDescriptorSetLayoutBinding const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>(this);
-    }
-
-    operator VkDescriptorSetLayoutBinding &()
-    {
-      return *reinterpret_cast<VkDescriptorSetLayoutBinding*>(this);
-    }
-
-    bool operator==( DescriptorSetLayoutBinding const& rhs ) const
-    {
-      return ( binding == rhs.binding )
-          && ( descriptorType == rhs.descriptorType )
-          && ( descriptorCount == rhs.descriptorCount )
-          && ( stageFlags == rhs.stageFlags )
-          && ( pImmutableSamplers == rhs.pImmutableSamplers );
-    }
-
-    bool operator!=( DescriptorSetLayoutBinding const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t binding;
-    DescriptorType descriptorType;
-    uint32_t descriptorCount;
-    ShaderStageFlags stageFlags;
-    const Sampler* pImmutableSamplers;
-  };
-  static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" );
-
-  struct PipelineShaderStageCreateInfo
-  {
-    PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(),
-                                   ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex,
-                                   ShaderModule module_ = ShaderModule(),
-                                   const char* pName_ = nullptr,
-                                   const SpecializationInfo* pSpecializationInfo_ = nullptr )
-      : flags( flags_ )
-      , stage( stage_ )
-      , module( module_ )
-      , pName( pName_ )
-      , pSpecializationInfo( pSpecializationInfo_ )
-    {
-    }
-
-    PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
-    }
-
-    PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
-      return *this;
-    }
-    PipelineShaderStageCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineShaderStageCreateInfo& setFlags( PipelineShaderStageCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineShaderStageCreateInfo& setStage( ShaderStageFlagBits stage_ )
-    {
-      stage = stage_;
-      return *this;
-    }
-
-    PipelineShaderStageCreateInfo& setModule( ShaderModule module_ )
-    {
-      module = module_;
-      return *this;
-    }
-
-    PipelineShaderStageCreateInfo& setPName( const char* pName_ )
-    {
-      pName = pName_;
-      return *this;
-    }
-
-    PipelineShaderStageCreateInfo& setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ )
-    {
-      pSpecializationInfo = pSpecializationInfo_;
-      return *this;
-    }
-
-    operator VkPipelineShaderStageCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(this);
-    }
-
-    operator VkPipelineShaderStageCreateInfo &()
-    {
-      return *reinterpret_cast<VkPipelineShaderStageCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineShaderStageCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( stage == rhs.stage )
-          && ( module == rhs.module )
-          && ( pName == rhs.pName )
-          && ( pSpecializationInfo == rhs.pSpecializationInfo );
-    }
-
-    bool operator!=( PipelineShaderStageCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineShaderStageCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineShaderStageCreateFlags flags;
-    ShaderStageFlagBits stage;
-    ShaderModule module;
-    const char* pName;
-    const SpecializationInfo* pSpecializationInfo;
-  };
-  static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" );
-
-  struct PushConstantRange
-  {
-    PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(),
-                       uint32_t offset_ = 0,
-                       uint32_t size_ = 0 )
-      : stageFlags( stageFlags_ )
-      , offset( offset_ )
-      , size( size_ )
-    {
-    }
-
-    PushConstantRange( VkPushConstantRange const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PushConstantRange ) );
-    }
-
-    PushConstantRange& operator=( VkPushConstantRange const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PushConstantRange ) );
-      return *this;
-    }
-    PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ )
-    {
-      stageFlags = stageFlags_;
-      return *this;
-    }
-
-    PushConstantRange& setOffset( uint32_t offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    PushConstantRange& setSize( uint32_t size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    operator VkPushConstantRange const&() const
-    {
-      return *reinterpret_cast<const VkPushConstantRange*>(this);
-    }
-
-    operator VkPushConstantRange &()
-    {
-      return *reinterpret_cast<VkPushConstantRange*>(this);
-    }
-
-    bool operator==( PushConstantRange const& rhs ) const
-    {
-      return ( stageFlags == rhs.stageFlags )
-          && ( offset == rhs.offset )
-          && ( size == rhs.size );
-    }
-
-    bool operator!=( PushConstantRange const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ShaderStageFlags stageFlags;
-    uint32_t offset;
-    uint32_t size;
-  };
-  static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" );
-
-  struct PipelineLayoutCreateInfo
-  {
-    PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(),
-                              uint32_t setLayoutCount_ = 0,
-                              const DescriptorSetLayout* pSetLayouts_ = nullptr,
-                              uint32_t pushConstantRangeCount_ = 0,
-                              const PushConstantRange* pPushConstantRanges_ = nullptr )
-      : flags( flags_ )
-      , setLayoutCount( setLayoutCount_ )
-      , pSetLayouts( pSetLayouts_ )
-      , pushConstantRangeCount( pushConstantRangeCount_ )
-      , pPushConstantRanges( pPushConstantRanges_ )
-    {
-    }
-
-    PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
-    }
-
-    PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
-      return *this;
-    }
-    PipelineLayoutCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineLayoutCreateInfo& setFlags( PipelineLayoutCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineLayoutCreateInfo& setSetLayoutCount( uint32_t setLayoutCount_ )
-    {
-      setLayoutCount = setLayoutCount_;
-      return *this;
-    }
-
-    PipelineLayoutCreateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
-    {
-      pSetLayouts = pSetLayouts_;
-      return *this;
-    }
-
-    PipelineLayoutCreateInfo& setPushConstantRangeCount( uint32_t pushConstantRangeCount_ )
-    {
-      pushConstantRangeCount = pushConstantRangeCount_;
-      return *this;
-    }
-
-    PipelineLayoutCreateInfo& setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ )
-    {
-      pPushConstantRanges = pPushConstantRanges_;
-      return *this;
-    }
-
-    operator VkPipelineLayoutCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkPipelineLayoutCreateInfo*>(this);
-    }
-
-    operator VkPipelineLayoutCreateInfo &()
-    {
-      return *reinterpret_cast<VkPipelineLayoutCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineLayoutCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( setLayoutCount == rhs.setLayoutCount )
-          && ( pSetLayouts == rhs.pSetLayouts )
-          && ( pushConstantRangeCount == rhs.pushConstantRangeCount )
-          && ( pPushConstantRanges == rhs.pPushConstantRanges );
-    }
-
-    bool operator!=( PipelineLayoutCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineLayoutCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineLayoutCreateFlags flags;
-    uint32_t setLayoutCount;
-    const DescriptorSetLayout* pSetLayouts;
-    uint32_t pushConstantRangeCount;
-    const PushConstantRange* pPushConstantRanges;
-  };
-  static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" );
-
-  struct ShaderStatisticsInfoAMD
-  {
-    operator VkShaderStatisticsInfoAMD const&() const
-    {
-      return *reinterpret_cast<const VkShaderStatisticsInfoAMD*>(this);
-    }
-
-    operator VkShaderStatisticsInfoAMD &()
-    {
-      return *reinterpret_cast<VkShaderStatisticsInfoAMD*>(this);
-    }
-
-    bool operator==( ShaderStatisticsInfoAMD const& rhs ) const
-    {
-      return ( shaderStageMask == rhs.shaderStageMask )
-          && ( resourceUsage == rhs.resourceUsage )
-          && ( numPhysicalVgprs == rhs.numPhysicalVgprs )
-          && ( numPhysicalSgprs == rhs.numPhysicalSgprs )
-          && ( numAvailableVgprs == rhs.numAvailableVgprs )
-          && ( numAvailableSgprs == rhs.numAvailableSgprs )
-          && ( memcmp( computeWorkGroupSize, rhs.computeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 );
-    }
-
-    bool operator!=( ShaderStatisticsInfoAMD const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ShaderStageFlags shaderStageMask;
-    ShaderResourceUsageAMD resourceUsage;
-    uint32_t numPhysicalVgprs;
-    uint32_t numPhysicalSgprs;
-    uint32_t numAvailableVgprs;
-    uint32_t numAvailableSgprs;
-    uint32_t computeWorkGroupSize[3];
-  };
-  static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" );
-
-  enum class ImageUsageFlagBits
-  {
-    eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
-    eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
-    eSampled = VK_IMAGE_USAGE_SAMPLED_BIT,
-    eStorage = VK_IMAGE_USAGE_STORAGE_BIT,
-    eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
-    eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
-    eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
-    eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
-    eShadingRateImageNV = VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV,
-    eFragmentDensityMapEXT = VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT
-  };
-
-  using ImageUsageFlags = Flags<ImageUsageFlagBits, VkImageUsageFlags>;
-
-  VULKAN_HPP_INLINE ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
-  {
-    return ImageUsageFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ImageUsageFlags operator~( ImageUsageFlagBits bits )
-  {
-    return ~( ImageUsageFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ImageUsageFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment) | VkFlags(ImageUsageFlagBits::eShadingRateImageNV) | VkFlags(ImageUsageFlagBits::eFragmentDensityMapEXT)
-    };
-  };
-
-  struct SharedPresentSurfaceCapabilitiesKHR
-  {
-    operator VkSharedPresentSurfaceCapabilitiesKHR const&() const
-    {
-      return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(this);
-    }
-
-    operator VkSharedPresentSurfaceCapabilitiesKHR &()
-    {
-      return *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(this);
-    }
-
-    bool operator==( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags );
-    }
-
-    bool operator!=( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    ImageUsageFlags sharedPresentSupportedUsageFlags;
-  };
-  static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
-
-  struct ImageViewUsageCreateInfo
-  {
-    ImageViewUsageCreateInfo( ImageUsageFlags usage_ = ImageUsageFlags() )
-      : usage( usage_ )
-    {
-    }
-
-    ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) );
-    }
-
-    ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) );
-      return *this;
-    }
-    ImageViewUsageCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageViewUsageCreateInfo& setUsage( ImageUsageFlags usage_ )
-    {
-      usage = usage_;
-      return *this;
-    }
-
-    operator VkImageViewUsageCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkImageViewUsageCreateInfo*>(this);
-    }
-
-    operator VkImageViewUsageCreateInfo &()
-    {
-      return *reinterpret_cast<VkImageViewUsageCreateInfo*>(this);
-    }
-
-    bool operator==( ImageViewUsageCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( usage == rhs.usage );
-    }
-
-    bool operator!=( ImageViewUsageCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageViewUsageCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ImageUsageFlags usage;
-  };
-  static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "struct and wrapper have different size!" );
-
-  using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
-
-  struct ImageStencilUsageCreateInfoEXT
-  {
-    ImageStencilUsageCreateInfoEXT( ImageUsageFlags stencilUsage_ = ImageUsageFlags() )
-      : stencilUsage( stencilUsage_ )
-    {
-    }
-
-    ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageStencilUsageCreateInfoEXT ) );
-    }
-
-    ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageStencilUsageCreateInfoEXT ) );
-      return *this;
-    }
-    ImageStencilUsageCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageStencilUsageCreateInfoEXT& setStencilUsage( ImageUsageFlags stencilUsage_ )
-    {
-      stencilUsage = stencilUsage_;
-      return *this;
-    }
-
-    operator VkImageStencilUsageCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkImageStencilUsageCreateInfoEXT*>(this);
-    }
-
-    operator VkImageStencilUsageCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkImageStencilUsageCreateInfoEXT*>(this);
-    }
-
-    bool operator==( ImageStencilUsageCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( stencilUsage == rhs.stencilUsage );
-    }
-
-    bool operator!=( ImageStencilUsageCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageStencilUsageCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ImageUsageFlags stencilUsage;
-  };
-  static_assert( sizeof( ImageStencilUsageCreateInfoEXT ) == sizeof( VkImageStencilUsageCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class ImageCreateFlagBits
-  {
-    eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT,
-    eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,
-    eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
-    eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
-    eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
-    eAlias = VK_IMAGE_CREATE_ALIAS_BIT,
-    eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT,
-    eSplitInstanceBindRegions = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
-    eSplitInstanceBindRegionsKHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
-    e2DArrayCompatible = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
-    e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
-    eBlockTexelViewCompatible = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
-    eBlockTexelViewCompatibleKHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
-    eExtendedUsage = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
-    eExtendedUsageKHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
-    eProtected = VK_IMAGE_CREATE_PROTECTED_BIT,
-    eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT,
-    eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT,
-    eCornerSampledNV = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV,
-    eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT,
-    eSubsampledEXT = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT
-  };
-
-  using ImageCreateFlags = Flags<ImageCreateFlagBits, VkImageCreateFlags>;
-
-  VULKAN_HPP_INLINE ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
-  {
-    return ImageCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ImageCreateFlags operator~( ImageCreateFlagBits bits )
-  {
-    return ~( ImageCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ImageCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eAlias) | VkFlags(ImageCreateFlagBits::eSplitInstanceBindRegions) | VkFlags(ImageCreateFlagBits::e2DArrayCompatible) | VkFlags(ImageCreateFlagBits::eBlockTexelViewCompatible) | VkFlags(ImageCreateFlagBits::eExtendedUsage) | VkFlags(ImageCreateFlagBits::eProtected) | VkFlags(ImageCreateFlagBits::eDisjoint) | VkFlags(ImageCreateFlagBits::eCornerSampledNV) | VkFlags(ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) | VkFlags(ImageCreateFlagBits::eSubsampledEXT)
-    };
-  };
+  static_assert( sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) == sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), "struct and wrapper have different size!" );
 
   struct PhysicalDeviceImageFormatInfo2
   {
@@ -23583,8 +36112,7 @@ public:
       , tiling( tiling_ )
       , usage( usage_ )
       , flags( flags_ )
-    {
-    }
+    {}
 
     PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs )
     {
@@ -23596,37 +36124,38 @@ public:
       memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) );
       return *this;
     }
-    PhysicalDeviceImageFormatInfo2& setPNext( const void* pNext_ )
+
+    PhysicalDeviceImageFormatInfo2 & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PhysicalDeviceImageFormatInfo2& setFormat( Format format_ )
+    PhysicalDeviceImageFormatInfo2 & setFormat( Format format_ )
     {
       format = format_;
       return *this;
     }
 
-    PhysicalDeviceImageFormatInfo2& setType( ImageType type_ )
+    PhysicalDeviceImageFormatInfo2 & setType( ImageType type_ )
     {
       type = type_;
       return *this;
     }
 
-    PhysicalDeviceImageFormatInfo2& setTiling( ImageTiling tiling_ )
+    PhysicalDeviceImageFormatInfo2 & setTiling( ImageTiling tiling_ )
     {
       tiling = tiling_;
       return *this;
     }
 
-    PhysicalDeviceImageFormatInfo2& setUsage( ImageUsageFlags usage_ )
+    PhysicalDeviceImageFormatInfo2 & setUsage( ImageUsageFlags usage_ )
     {
       usage = usage_;
       return *this;
     }
 
-    PhysicalDeviceImageFormatInfo2& setFlags( ImageCreateFlags flags_ )
+    PhysicalDeviceImageFormatInfo2 & setFlags( ImageCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
@@ -23634,12 +36163,12 @@ public:
 
     operator VkPhysicalDeviceImageFormatInfo2 const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( this );
     }
 
     operator VkPhysicalDeviceImageFormatInfo2 &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>( this );
     }
 
     bool operator==( PhysicalDeviceImageFormatInfo2 const& rhs ) const
@@ -23671,4187 +36200,92 @@ public:
   };
   static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "struct and wrapper have different size!" );
 
-  using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
-
-  enum class ImageViewCreateFlagBits
+  struct PhysicalDeviceInlineUniformBlockFeaturesEXT
   {
-    eFragmentDensityMapDynamicEXT = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT
-  };
-
-  using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits, VkImageViewCreateFlags>;
-
-  VULKAN_HPP_INLINE ImageViewCreateFlags operator|( ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1 )
-  {
-    return ImageViewCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ImageViewCreateFlags operator~( ImageViewCreateFlagBits bits )
-  {
-    return ~( ImageViewCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ImageViewCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT)
-    };
-  };
-
-  enum class SamplerCreateFlagBits
-  {
-    eSubsampledEXT = VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT,
-    eSubsampledCoarseReconstructionEXT = VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT
-  };
-
-  using SamplerCreateFlags = Flags<SamplerCreateFlagBits, VkSamplerCreateFlags>;
-
-  VULKAN_HPP_INLINE SamplerCreateFlags operator|( SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1 )
-  {
-    return SamplerCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SamplerCreateFlags operator~( SamplerCreateFlagBits bits )
-  {
-    return ~( SamplerCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<SamplerCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(SamplerCreateFlagBits::eSubsampledEXT) | VkFlags(SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT)
-    };
-  };
-
-  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 )
-      : flags( flags_ )
-      , magFilter( magFilter_ )
-      , minFilter( minFilter_ )
-      , mipmapMode( mipmapMode_ )
-      , addressModeU( addressModeU_ )
-      , addressModeV( addressModeV_ )
-      , addressModeW( addressModeW_ )
-      , mipLodBias( mipLodBias_ )
-      , anisotropyEnable( anisotropyEnable_ )
-      , maxAnisotropy( maxAnisotropy_ )
-      , compareEnable( compareEnable_ )
-      , compareOp( compareOp_ )
-      , minLod( minLod_ )
-      , maxLod( maxLod_ )
-      , borderColor( borderColor_ )
-      , unnormalizedCoordinates( unnormalizedCoordinates_ )
+    operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const&() const
     {
+      return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>( this );
     }
 
-    SamplerCreateInfo( VkSamplerCreateInfo const & rhs )
+    operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT &()
     {
-      memcpy( this, &rhs, sizeof( SamplerCreateInfo ) );
+      return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>( this );
     }
 
-    SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SamplerCreateInfo ) );
-      return *this;
-    }
-    SamplerCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setFlags( SamplerCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMagFilter( Filter magFilter_ )
-    {
-      magFilter = magFilter_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMinFilter( Filter minFilter_ )
-    {
-      minFilter = minFilter_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMipmapMode( SamplerMipmapMode mipmapMode_ )
-    {
-      mipmapMode = mipmapMode_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setAddressModeU( SamplerAddressMode addressModeU_ )
-    {
-      addressModeU = addressModeU_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setAddressModeV( SamplerAddressMode addressModeV_ )
-    {
-      addressModeV = addressModeV_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setAddressModeW( SamplerAddressMode addressModeW_ )
-    {
-      addressModeW = addressModeW_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMipLodBias( float mipLodBias_ )
-    {
-      mipLodBias = mipLodBias_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setAnisotropyEnable( Bool32 anisotropyEnable_ )
-    {
-      anisotropyEnable = anisotropyEnable_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMaxAnisotropy( float maxAnisotropy_ )
-    {
-      maxAnisotropy = maxAnisotropy_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setCompareEnable( Bool32 compareEnable_ )
-    {
-      compareEnable = compareEnable_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setCompareOp( CompareOp compareOp_ )
-    {
-      compareOp = compareOp_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMinLod( float minLod_ )
-    {
-      minLod = minLod_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMaxLod( float maxLod_ )
-    {
-      maxLod = maxLod_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setBorderColor( BorderColor borderColor_ )
-    {
-      borderColor = borderColor_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ )
-    {
-      unnormalizedCoordinates = unnormalizedCoordinates_;
-      return *this;
-    }
-
-    operator VkSamplerCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkSamplerCreateInfo*>(this);
-    }
-
-    operator VkSamplerCreateInfo &()
-    {
-      return *reinterpret_cast<VkSamplerCreateInfo*>(this);
-    }
-
-    bool operator==( SamplerCreateInfo const& rhs ) const
+    bool operator==( PhysicalDeviceInlineUniformBlockFeaturesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( magFilter == rhs.magFilter )
-          && ( minFilter == rhs.minFilter )
-          && ( mipmapMode == rhs.mipmapMode )
-          && ( addressModeU == rhs.addressModeU )
-          && ( addressModeV == rhs.addressModeV )
-          && ( addressModeW == rhs.addressModeW )
-          && ( mipLodBias == rhs.mipLodBias )
-          && ( anisotropyEnable == rhs.anisotropyEnable )
-          && ( maxAnisotropy == rhs.maxAnisotropy )
-          && ( compareEnable == rhs.compareEnable )
-          && ( compareOp == rhs.compareOp )
-          && ( minLod == rhs.minLod )
-          && ( maxLod == rhs.maxLod )
-          && ( borderColor == rhs.borderColor )
-          && ( unnormalizedCoordinates == rhs.unnormalizedCoordinates );
+          && ( inlineUniformBlock == rhs.inlineUniformBlock )
+          && ( descriptorBindingInlineUniformBlockUpdateAfterBind == rhs.descriptorBindingInlineUniformBlockUpdateAfterBind );
     }
 
-    bool operator!=( SamplerCreateInfo const& rhs ) const
+    bool operator!=( PhysicalDeviceInlineUniformBlockFeaturesEXT const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eSamplerCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    SamplerCreateFlags flags;
-    Filter magFilter;
-    Filter minFilter;
-    SamplerMipmapMode mipmapMode;
-    SamplerAddressMode addressModeU;
-    SamplerAddressMode addressModeV;
-    SamplerAddressMode addressModeW;
-    float mipLodBias;
-    Bool32 anisotropyEnable;
-    float maxAnisotropy;
-    Bool32 compareEnable;
-    CompareOp compareOp;
-    float minLod;
-    float maxLod;
-    BorderColor borderColor;
-    Bool32 unnormalizedCoordinates;
-  };
-  static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class PipelineCreateFlagBits
-  {
-    eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT,
-    eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,
-    eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT,
-    eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
-    eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
-    eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE,
-    eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
-    eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV
-  };
-
-  using PipelineCreateFlags = Flags<PipelineCreateFlagBits, VkPipelineCreateFlags>;
-
-  VULKAN_HPP_INLINE PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
-  {
-    return PipelineCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE PipelineCreateFlags operator~( PipelineCreateFlagBits bits )
-  {
-    return ~( PipelineCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<PipelineCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) | VkFlags(PipelineCreateFlagBits::eDeferCompileNV)
-    };
-  };
-
-  struct ComputePipelineCreateInfo
-  {
-    ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(),
-                               PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(),
-                               PipelineLayout layout_ = PipelineLayout(),
-                               Pipeline basePipelineHandle_ = Pipeline(),
-                               int32_t basePipelineIndex_ = 0 )
-      : flags( flags_ )
-      , stage( stage_ )
-      , layout( layout_ )
-      , basePipelineHandle( basePipelineHandle_ )
-      , basePipelineIndex( basePipelineIndex_ )
-    {
-    }
-
-    ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
-    }
-
-    ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
-      return *this;
-    }
-    ComputePipelineCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ComputePipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ComputePipelineCreateInfo& setStage( PipelineShaderStageCreateInfo stage_ )
-    {
-      stage = stage_;
-      return *this;
-    }
-
-    ComputePipelineCreateInfo& setLayout( PipelineLayout layout_ )
-    {
-      layout = layout_;
-      return *this;
-    }
-
-    ComputePipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
-    {
-      basePipelineHandle = basePipelineHandle_;
-      return *this;
-    }
-
-    ComputePipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
-    {
-      basePipelineIndex = basePipelineIndex_;
-      return *this;
-    }
-
-    operator VkComputePipelineCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkComputePipelineCreateInfo*>(this);
-    }
-
-    operator VkComputePipelineCreateInfo &()
-    {
-      return *reinterpret_cast<VkComputePipelineCreateInfo*>(this);
-    }
-
-    bool operator==( ComputePipelineCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( stage == rhs.stage )
-          && ( layout == rhs.layout )
-          && ( basePipelineHandle == rhs.basePipelineHandle )
-          && ( basePipelineIndex == rhs.basePipelineIndex );
-    }
-
-    bool operator!=( ComputePipelineCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eComputePipelineCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCreateFlags flags;
-    PipelineShaderStageCreateInfo stage;
-    PipelineLayout layout;
-    Pipeline basePipelineHandle;
-    int32_t basePipelineIndex;
-  };
-  static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class ColorComponentFlagBits
-  {
-    eR = VK_COLOR_COMPONENT_R_BIT,
-    eG = VK_COLOR_COMPONENT_G_BIT,
-    eB = VK_COLOR_COMPONENT_B_BIT,
-    eA = VK_COLOR_COMPONENT_A_BIT
-  };
-
-  using ColorComponentFlags = Flags<ColorComponentFlagBits, VkColorComponentFlags>;
-
-  VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
-  {
-    return ColorComponentFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits )
-  {
-    return ~( ColorComponentFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ColorComponentFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ColorComponentFlagBits::eR) | VkFlags(ColorComponentFlagBits::eG) | VkFlags(ColorComponentFlagBits::eB) | VkFlags(ColorComponentFlagBits::eA)
-    };
-  };
-
-  struct PipelineColorBlendAttachmentState
-  {
-    PipelineColorBlendAttachmentState( Bool32 blendEnable_ = 0,
-                                       BlendFactor srcColorBlendFactor_ = BlendFactor::eZero,
-                                       BlendFactor dstColorBlendFactor_ = BlendFactor::eZero,
-                                       BlendOp colorBlendOp_ = BlendOp::eAdd,
-                                       BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero,
-                                       BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero,
-                                       BlendOp alphaBlendOp_ = BlendOp::eAdd,
-                                       ColorComponentFlags colorWriteMask_ = ColorComponentFlags() )
-      : blendEnable( blendEnable_ )
-      , srcColorBlendFactor( srcColorBlendFactor_ )
-      , dstColorBlendFactor( dstColorBlendFactor_ )
-      , colorBlendOp( colorBlendOp_ )
-      , srcAlphaBlendFactor( srcAlphaBlendFactor_ )
-      , dstAlphaBlendFactor( dstAlphaBlendFactor_ )
-      , alphaBlendOp( alphaBlendOp_ )
-      , colorWriteMask( colorWriteMask_ )
-    {
-    }
-
-    PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
-    }
-
-    PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
-      return *this;
-    }
-    PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ )
-    {
-      blendEnable = blendEnable_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ )
-    {
-      srcColorBlendFactor = srcColorBlendFactor_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ )
-    {
-      dstColorBlendFactor = dstColorBlendFactor_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setColorBlendOp( BlendOp colorBlendOp_ )
-    {
-      colorBlendOp = colorBlendOp_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ )
-    {
-      srcAlphaBlendFactor = srcAlphaBlendFactor_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ )
-    {
-      dstAlphaBlendFactor = dstAlphaBlendFactor_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setAlphaBlendOp( BlendOp alphaBlendOp_ )
-    {
-      alphaBlendOp = alphaBlendOp_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setColorWriteMask( ColorComponentFlags colorWriteMask_ )
-    {
-      colorWriteMask = colorWriteMask_;
-      return *this;
-    }
-
-    operator VkPipelineColorBlendAttachmentState const&() const
-    {
-      return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>(this);
-    }
-
-    operator VkPipelineColorBlendAttachmentState &()
-    {
-      return *reinterpret_cast<VkPipelineColorBlendAttachmentState*>(this);
-    }
-
-    bool operator==( PipelineColorBlendAttachmentState const& rhs ) const
-    {
-      return ( blendEnable == rhs.blendEnable )
-          && ( srcColorBlendFactor == rhs.srcColorBlendFactor )
-          && ( dstColorBlendFactor == rhs.dstColorBlendFactor )
-          && ( colorBlendOp == rhs.colorBlendOp )
-          && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor )
-          && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor )
-          && ( alphaBlendOp == rhs.alphaBlendOp )
-          && ( colorWriteMask == rhs.colorWriteMask );
-    }
-
-    bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Bool32 blendEnable;
-    BlendFactor srcColorBlendFactor;
-    BlendFactor dstColorBlendFactor;
-    BlendOp colorBlendOp;
-    BlendFactor srcAlphaBlendFactor;
-    BlendFactor dstAlphaBlendFactor;
-    BlendOp alphaBlendOp;
-    ColorComponentFlags colorWriteMask;
-  };
-  static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" );
-
-  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 } } )
-      : flags( flags_ )
-      , logicOpEnable( logicOpEnable_ )
-      , logicOp( logicOp_ )
-      , attachmentCount( attachmentCount_ )
-      , pAttachments( pAttachments_ )
-    {
-      memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
-    }
-
-    PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
-    }
-
-    PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
-      return *this;
-    }
-    PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineColorBlendStateCreateInfo& setFlags( PipelineColorBlendStateCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineColorBlendStateCreateInfo& setLogicOpEnable( Bool32 logicOpEnable_ )
-    {
-      logicOpEnable = logicOpEnable_;
-      return *this;
-    }
-
-    PipelineColorBlendStateCreateInfo& setLogicOp( LogicOp logicOp_ )
-    {
-      logicOp = logicOp_;
-      return *this;
-    }
-
-    PipelineColorBlendStateCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
-    {
-      attachmentCount = attachmentCount_;
-      return *this;
-    }
-
-    PipelineColorBlendStateCreateInfo& setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ )
-    {
-      pAttachments = pAttachments_;
-      return *this;
-    }
-
-    PipelineColorBlendStateCreateInfo& setBlendConstants( std::array<float,4> blendConstants_ )
-    {
-      memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
-      return *this;
-    }
-
-    operator VkPipelineColorBlendStateCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(this);
-    }
-
-    operator VkPipelineColorBlendStateCreateInfo &()
-    {
-      return *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( logicOpEnable == rhs.logicOpEnable )
-          && ( logicOp == rhs.logicOp )
-          && ( attachmentCount == rhs.attachmentCount )
-          && ( pAttachments == rhs.pAttachments )
-          && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 );
-    }
-
-    bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineColorBlendStateCreateFlags flags;
-    Bool32 logicOpEnable;
-    LogicOp logicOp;
-    uint32_t attachmentCount;
-    const PipelineColorBlendAttachmentState* pAttachments;
-    float blendConstants[4];
-  };
-  static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class FenceCreateFlagBits
-  {
-    eSignaled = VK_FENCE_CREATE_SIGNALED_BIT
-  };
-
-  using FenceCreateFlags = Flags<FenceCreateFlagBits, VkFenceCreateFlags>;
-
-  VULKAN_HPP_INLINE FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
-  {
-    return FenceCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE FenceCreateFlags operator~( FenceCreateFlagBits bits )
-  {
-    return ~( FenceCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<FenceCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(FenceCreateFlagBits::eSignaled)
-    };
-  };
-
-  struct FenceCreateInfo
-  {
-    FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() )
-      : flags( flags_ )
-    {
-    }
-
-    FenceCreateInfo( VkFenceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
-    }
-
-    FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
-      return *this;
-    }
-    FenceCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    FenceCreateInfo& setFlags( FenceCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator VkFenceCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkFenceCreateInfo*>(this);
-    }
-
-    operator VkFenceCreateInfo &()
-    {
-      return *reinterpret_cast<VkFenceCreateInfo*>(this);
-    }
-
-    bool operator==( FenceCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( FenceCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eFenceCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    FenceCreateFlags flags;
-  };
-  static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class FormatFeatureFlagBits
-  {
-    eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
-    eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
-    eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,
-    eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT,
-    eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT,
-    eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT,
-    eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
-    eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
-    eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,
-    eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
-    eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT,
-    eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT,
-    eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
-    eTransferSrc = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
-    eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
-    eTransferDst = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
-    eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
-    eMidpointChromaSamples = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
-    eMidpointChromaSamplesKHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
-    eSampledImageYcbcrConversionLinearFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
-    eSampledImageYcbcrConversionLinearFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
-    eSampledImageYcbcrConversionSeparateReconstructionFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
-    eSampledImageYcbcrConversionSeparateReconstructionFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
-    eSampledImageYcbcrConversionChromaReconstructionExplicit = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
-    eSampledImageYcbcrConversionChromaReconstructionExplicitKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
-    eSampledImageYcbcrConversionChromaReconstructionExplicitForceable = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
-    eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
-    eDisjoint = VK_FORMAT_FEATURE_DISJOINT_BIT,
-    eDisjointKHR = VK_FORMAT_FEATURE_DISJOINT_BIT,
-    eCositedChromaSamples = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
-    eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
-    eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
-    eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT,
-    eFragmentDensityMapEXT = VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT
-  };
-
-  using FormatFeatureFlags = Flags<FormatFeatureFlagBits, VkFormatFeatureFlags>;
-
-  VULKAN_HPP_INLINE FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
-  {
-    return FormatFeatureFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE FormatFeatureFlags operator~( FormatFeatureFlagBits bits )
-  {
-    return ~( FormatFeatureFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<FormatFeatureFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eTransferSrc) | VkFlags(FormatFeatureFlagBits::eTransferDst) | VkFlags(FormatFeatureFlagBits::eMidpointChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable) | VkFlags(FormatFeatureFlagBits::eDisjoint) | VkFlags(FormatFeatureFlagBits::eCositedChromaSamples) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) | VkFlags(FormatFeatureFlagBits::eFragmentDensityMapEXT)
-    };
-  };
-
-  struct FormatProperties
-  {
-    operator VkFormatProperties const&() const
-    {
-      return *reinterpret_cast<const VkFormatProperties*>(this);
-    }
-
-    operator VkFormatProperties &()
-    {
-      return *reinterpret_cast<VkFormatProperties*>(this);
-    }
-
-    bool operator==( FormatProperties const& rhs ) const
-    {
-      return ( linearTilingFeatures == rhs.linearTilingFeatures )
-          && ( optimalTilingFeatures == rhs.optimalTilingFeatures )
-          && ( bufferFeatures == rhs.bufferFeatures );
-    }
-
-    bool operator!=( FormatProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    FormatFeatureFlags linearTilingFeatures;
-    FormatFeatureFlags optimalTilingFeatures;
-    FormatFeatureFlags bufferFeatures;
-  };
-  static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" );
-
-  struct FormatProperties2
-  {
-    operator VkFormatProperties2 const&() const
-    {
-      return *reinterpret_cast<const VkFormatProperties2*>(this);
-    }
-
-    operator VkFormatProperties2 &()
-    {
-      return *reinterpret_cast<VkFormatProperties2*>(this);
-    }
-
-    bool operator==( FormatProperties2 const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( formatProperties == rhs.formatProperties );
-    }
-
-    bool operator!=( FormatProperties2 const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eFormatProperties2;
+    StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT;
 
   public:
     void* pNext = nullptr;
-    FormatProperties formatProperties;
+    Bool32 inlineUniformBlock;
+    Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
   };
-  static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "struct and wrapper have different size!" );
 
-  using FormatProperties2KHR = FormatProperties2;
-
-  struct DrmFormatModifierPropertiesEXT
+  struct PhysicalDeviceInlineUniformBlockPropertiesEXT
   {
-    operator VkDrmFormatModifierPropertiesEXT const&() const
+    operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const&() const
     {
-      return *reinterpret_cast<const VkDrmFormatModifierPropertiesEXT*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>( this );
     }
 
-    operator VkDrmFormatModifierPropertiesEXT &()
+    operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT &()
     {
-      return *reinterpret_cast<VkDrmFormatModifierPropertiesEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>( this );
     }
 
-    bool operator==( DrmFormatModifierPropertiesEXT const& rhs ) const
-    {
-      return ( drmFormatModifier == rhs.drmFormatModifier )
-          && ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount )
-          && ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures );
-    }
-
-    bool operator!=( DrmFormatModifierPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint64_t drmFormatModifier;
-    uint32_t drmFormatModifierPlaneCount;
-    FormatFeatureFlags drmFormatModifierTilingFeatures;
-  };
-  static_assert( sizeof( DrmFormatModifierPropertiesEXT ) == sizeof( VkDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
-
-  struct DrmFormatModifierPropertiesListEXT
-  {
-    DrmFormatModifierPropertiesListEXT( uint32_t drmFormatModifierCount_ = 0,
-                                        DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties_ = nullptr )
-      : drmFormatModifierCount( drmFormatModifierCount_ )
-      , pDrmFormatModifierProperties( pDrmFormatModifierProperties_ )
-    {
-    }
-
-    DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrmFormatModifierPropertiesListEXT ) );
-    }
-
-    DrmFormatModifierPropertiesListEXT& operator=( VkDrmFormatModifierPropertiesListEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrmFormatModifierPropertiesListEXT ) );
-      return *this;
-    }
-    DrmFormatModifierPropertiesListEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DrmFormatModifierPropertiesListEXT& setDrmFormatModifierCount( uint32_t drmFormatModifierCount_ )
-    {
-      drmFormatModifierCount = drmFormatModifierCount_;
-      return *this;
-    }
-
-    DrmFormatModifierPropertiesListEXT& setPDrmFormatModifierProperties( DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties_ )
-    {
-      pDrmFormatModifierProperties = pDrmFormatModifierProperties_;
-      return *this;
-    }
-
-    operator VkDrmFormatModifierPropertiesListEXT const&() const
-    {
-      return *reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(this);
-    }
-
-    operator VkDrmFormatModifierPropertiesListEXT &()
-    {
-      return *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(this);
-    }
-
-    bool operator==( DrmFormatModifierPropertiesListEXT const& rhs ) const
+    bool operator==( PhysicalDeviceInlineUniformBlockPropertiesEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( drmFormatModifierCount == rhs.drmFormatModifierCount )
-          && ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties );
+          && ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize )
+          && ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks )
+          && ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks == rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks )
+          && ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks )
+          && ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks == rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
     }
 
-    bool operator!=( DrmFormatModifierPropertiesListEXT const& rhs ) const
+    bool operator!=( PhysicalDeviceInlineUniformBlockPropertiesEXT const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT;
+    StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT;
 
   public:
     void* pNext = nullptr;
-    uint32_t drmFormatModifierCount;
-    DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties;
+    uint32_t maxInlineUniformBlockSize;
+    uint32_t maxPerStageDescriptorInlineUniformBlocks;
+    uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    uint32_t maxDescriptorSetInlineUniformBlocks;
+    uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
   };
-  static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "struct and wrapper have different size!" );
-
-  enum class QueryControlFlagBits
-  {
-    ePrecise = VK_QUERY_CONTROL_PRECISE_BIT
-  };
-
-  using QueryControlFlags = Flags<QueryControlFlagBits, VkQueryControlFlags>;
-
-  VULKAN_HPP_INLINE QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
-  {
-    return QueryControlFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE QueryControlFlags operator~( QueryControlFlagBits bits )
-  {
-    return ~( QueryControlFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<QueryControlFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(QueryControlFlagBits::ePrecise)
-    };
-  };
-
-  enum class QueryResultFlagBits
-  {
-    e64 = VK_QUERY_RESULT_64_BIT,
-    eWait = VK_QUERY_RESULT_WAIT_BIT,
-    eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT,
-    ePartial = VK_QUERY_RESULT_PARTIAL_BIT
-  };
-
-  using QueryResultFlags = Flags<QueryResultFlagBits, VkQueryResultFlags>;
-
-  VULKAN_HPP_INLINE QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
-  {
-    return QueryResultFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE QueryResultFlags operator~( QueryResultFlagBits bits )
-  {
-    return ~( QueryResultFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<QueryResultFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(QueryResultFlagBits::e64) | VkFlags(QueryResultFlagBits::eWait) | VkFlags(QueryResultFlagBits::eWithAvailability) | VkFlags(QueryResultFlagBits::ePartial)
-    };
-  };
-
-  enum class CommandBufferUsageFlagBits
-  {
-    eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
-    eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
-    eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
-  };
-
-  using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits, VkCommandBufferUsageFlags>;
-
-  VULKAN_HPP_INLINE CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
-  {
-    return CommandBufferUsageFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits )
-  {
-    return ~( CommandBufferUsageFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<CommandBufferUsageFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) | VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) | VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse)
-    };
-  };
-
-  enum class QueryPipelineStatisticFlagBits
-  {
-    eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT,
-    eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT,
-    eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT,
-    eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT,
-    eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT,
-    eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT,
-    eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT,
-    eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT,
-    eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT,
-    eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT,
-    eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
-  };
-
-  using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits, VkQueryPipelineStatisticFlags>;
-
-  VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
-  {
-    return QueryPipelineStatisticFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits )
-  {
-    return ~( QueryPipelineStatisticFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<QueryPipelineStatisticFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) | VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations)
-    };
-  };
-
-  struct CommandBufferInheritanceInfo
-  {
-    CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(),
-                                  uint32_t subpass_ = 0,
-                                  Framebuffer framebuffer_ = Framebuffer(),
-                                  Bool32 occlusionQueryEnable_ = 0,
-                                  QueryControlFlags queryFlags_ = QueryControlFlags(),
-                                  QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
-      : renderPass( renderPass_ )
-      , subpass( subpass_ )
-      , framebuffer( framebuffer_ )
-      , occlusionQueryEnable( occlusionQueryEnable_ )
-      , queryFlags( queryFlags_ )
-      , pipelineStatistics( pipelineStatistics_ )
-    {
-    }
-
-    CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
-    }
-
-    CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
-      return *this;
-    }
-    CommandBufferInheritanceInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CommandBufferInheritanceInfo& setRenderPass( RenderPass renderPass_ )
-    {
-      renderPass = renderPass_;
-      return *this;
-    }
-
-    CommandBufferInheritanceInfo& setSubpass( uint32_t subpass_ )
-    {
-      subpass = subpass_;
-      return *this;
-    }
-
-    CommandBufferInheritanceInfo& setFramebuffer( Framebuffer framebuffer_ )
-    {
-      framebuffer = framebuffer_;
-      return *this;
-    }
-
-    CommandBufferInheritanceInfo& setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ )
-    {
-      occlusionQueryEnable = occlusionQueryEnable_;
-      return *this;
-    }
-
-    CommandBufferInheritanceInfo& setQueryFlags( QueryControlFlags queryFlags_ )
-    {
-      queryFlags = queryFlags_;
-      return *this;
-    }
-
-    CommandBufferInheritanceInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
-    {
-      pipelineStatistics = pipelineStatistics_;
-      return *this;
-    }
-
-    operator VkCommandBufferInheritanceInfo const&() const
-    {
-      return *reinterpret_cast<const VkCommandBufferInheritanceInfo*>(this);
-    }
-
-    operator VkCommandBufferInheritanceInfo &()
-    {
-      return *reinterpret_cast<VkCommandBufferInheritanceInfo*>(this);
-    }
-
-    bool operator==( CommandBufferInheritanceInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( renderPass == rhs.renderPass )
-          && ( subpass == rhs.subpass )
-          && ( framebuffer == rhs.framebuffer )
-          && ( occlusionQueryEnable == rhs.occlusionQueryEnable )
-          && ( queryFlags == rhs.queryFlags )
-          && ( pipelineStatistics == rhs.pipelineStatistics );
-    }
-
-    bool operator!=( CommandBufferInheritanceInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCommandBufferInheritanceInfo;
-
-  public:
-    const void* pNext = nullptr;
-    RenderPass renderPass;
-    uint32_t subpass;
-    Framebuffer framebuffer;
-    Bool32 occlusionQueryEnable;
-    QueryControlFlags queryFlags;
-    QueryPipelineStatisticFlags pipelineStatistics;
-  };
-  static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" );
-
-  struct CommandBufferBeginInfo
-  {
-    CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(),
-                            const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
-      : flags( flags_ )
-      , pInheritanceInfo( pInheritanceInfo_ )
-    {
-    }
-
-    CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
-    }
-
-    CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
-      return *this;
-    }
-    CommandBufferBeginInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CommandBufferBeginInfo& setFlags( CommandBufferUsageFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    CommandBufferBeginInfo& setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ )
-    {
-      pInheritanceInfo = pInheritanceInfo_;
-      return *this;
-    }
-
-    operator VkCommandBufferBeginInfo const&() const
-    {
-      return *reinterpret_cast<const VkCommandBufferBeginInfo*>(this);
-    }
-
-    operator VkCommandBufferBeginInfo &()
-    {
-      return *reinterpret_cast<VkCommandBufferBeginInfo*>(this);
-    }
-
-    bool operator==( CommandBufferBeginInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( pInheritanceInfo == rhs.pInheritanceInfo );
-    }
-
-    bool operator!=( CommandBufferBeginInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCommandBufferBeginInfo;
-
-  public:
-    const void* pNext = nullptr;
-    CommandBufferUsageFlags flags;
-    const CommandBufferInheritanceInfo* pInheritanceInfo;
-  };
-  static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" );
-
-  struct QueryPoolCreateInfo
-  {
-    QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(),
-                         QueryType queryType_ = QueryType::eOcclusion,
-                         uint32_t queryCount_ = 0,
-                         QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
-      : flags( flags_ )
-      , queryType( queryType_ )
-      , queryCount( queryCount_ )
-      , pipelineStatistics( pipelineStatistics_ )
-    {
-    }
-
-    QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
-    }
-
-    QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
-      return *this;
-    }
-    QueryPoolCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    QueryPoolCreateInfo& setFlags( QueryPoolCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    QueryPoolCreateInfo& setQueryType( QueryType queryType_ )
-    {
-      queryType = queryType_;
-      return *this;
-    }
-
-    QueryPoolCreateInfo& setQueryCount( uint32_t queryCount_ )
-    {
-      queryCount = queryCount_;
-      return *this;
-    }
-
-    QueryPoolCreateInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
-    {
-      pipelineStatistics = pipelineStatistics_;
-      return *this;
-    }
-
-    operator VkQueryPoolCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkQueryPoolCreateInfo*>(this);
-    }
-
-    operator VkQueryPoolCreateInfo &()
-    {
-      return *reinterpret_cast<VkQueryPoolCreateInfo*>(this);
-    }
-
-    bool operator==( QueryPoolCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( queryType == rhs.queryType )
-          && ( queryCount == rhs.queryCount )
-          && ( pipelineStatistics == rhs.pipelineStatistics );
-    }
-
-    bool operator!=( QueryPoolCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eQueryPoolCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    QueryPoolCreateFlags flags;
-    QueryType queryType;
-    uint32_t queryCount;
-    QueryPipelineStatisticFlags pipelineStatistics;
-  };
-  static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class ImageAspectFlagBits
-  {
-    eColor = VK_IMAGE_ASPECT_COLOR_BIT,
-    eDepth = VK_IMAGE_ASPECT_DEPTH_BIT,
-    eStencil = VK_IMAGE_ASPECT_STENCIL_BIT,
-    eMetadata = VK_IMAGE_ASPECT_METADATA_BIT,
-    ePlane0 = VK_IMAGE_ASPECT_PLANE_0_BIT,
-    ePlane0KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,
-    ePlane1 = VK_IMAGE_ASPECT_PLANE_1_BIT,
-    ePlane1KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,
-    ePlane2 = VK_IMAGE_ASPECT_PLANE_2_BIT,
-    ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT,
-    eMemoryPlane0EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT,
-    eMemoryPlane1EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT,
-    eMemoryPlane2EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT,
-    eMemoryPlane3EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT
-  };
-
-  using ImageAspectFlags = Flags<ImageAspectFlagBits, VkImageAspectFlags>;
-
-  VULKAN_HPP_INLINE ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
-  {
-    return ImageAspectFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ImageAspectFlags operator~( ImageAspectFlagBits bits )
-  {
-    return ~( ImageAspectFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ImageAspectFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ImageAspectFlagBits::eColor) | VkFlags(ImageAspectFlagBits::eDepth) | VkFlags(ImageAspectFlagBits::eStencil) | VkFlags(ImageAspectFlagBits::eMetadata) | VkFlags(ImageAspectFlagBits::ePlane0) | VkFlags(ImageAspectFlagBits::ePlane1) | VkFlags(ImageAspectFlagBits::ePlane2) | VkFlags(ImageAspectFlagBits::eMemoryPlane0EXT) | VkFlags(ImageAspectFlagBits::eMemoryPlane1EXT) | VkFlags(ImageAspectFlagBits::eMemoryPlane2EXT) | VkFlags(ImageAspectFlagBits::eMemoryPlane3EXT)
-    };
-  };
-
-  struct ImageSubresource
-  {
-    ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
-                      uint32_t mipLevel_ = 0,
-                      uint32_t arrayLayer_ = 0 )
-      : aspectMask( aspectMask_ )
-      , mipLevel( mipLevel_ )
-      , arrayLayer( arrayLayer_ )
-    {
-    }
-
-    ImageSubresource( VkImageSubresource const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSubresource ) );
-    }
-
-    ImageSubresource& operator=( VkImageSubresource const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSubresource ) );
-      return *this;
-    }
-    ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ )
-    {
-      aspectMask = aspectMask_;
-      return *this;
-    }
-
-    ImageSubresource& setMipLevel( uint32_t mipLevel_ )
-    {
-      mipLevel = mipLevel_;
-      return *this;
-    }
-
-    ImageSubresource& setArrayLayer( uint32_t arrayLayer_ )
-    {
-      arrayLayer = arrayLayer_;
-      return *this;
-    }
-
-    operator VkImageSubresource const&() const
-    {
-      return *reinterpret_cast<const VkImageSubresource*>(this);
-    }
-
-    operator VkImageSubresource &()
-    {
-      return *reinterpret_cast<VkImageSubresource*>(this);
-    }
-
-    bool operator==( ImageSubresource const& rhs ) const
-    {
-      return ( aspectMask == rhs.aspectMask )
-          && ( mipLevel == rhs.mipLevel )
-          && ( arrayLayer == rhs.arrayLayer );
-    }
-
-    bool operator!=( ImageSubresource const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageAspectFlags aspectMask;
-    uint32_t mipLevel;
-    uint32_t arrayLayer;
-  };
-  static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" );
-
-  struct ImageSubresourceLayers
-  {
-    ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
-                            uint32_t mipLevel_ = 0,
-                            uint32_t baseArrayLayer_ = 0,
-                            uint32_t layerCount_ = 0 )
-      : aspectMask( aspectMask_ )
-      , mipLevel( mipLevel_ )
-      , baseArrayLayer( baseArrayLayer_ )
-      , layerCount( layerCount_ )
-    {
-    }
-
-    ImageSubresourceLayers( VkImageSubresourceLayers const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
-    }
-
-    ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
-      return *this;
-    }
-    ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ )
-    {
-      aspectMask = aspectMask_;
-      return *this;
-    }
-
-    ImageSubresourceLayers& setMipLevel( uint32_t mipLevel_ )
-    {
-      mipLevel = mipLevel_;
-      return *this;
-    }
-
-    ImageSubresourceLayers& setBaseArrayLayer( uint32_t baseArrayLayer_ )
-    {
-      baseArrayLayer = baseArrayLayer_;
-      return *this;
-    }
-
-    ImageSubresourceLayers& setLayerCount( uint32_t layerCount_ )
-    {
-      layerCount = layerCount_;
-      return *this;
-    }
-
-    operator VkImageSubresourceLayers const&() const
-    {
-      return *reinterpret_cast<const VkImageSubresourceLayers*>(this);
-    }
-
-    operator VkImageSubresourceLayers &()
-    {
-      return *reinterpret_cast<VkImageSubresourceLayers*>(this);
-    }
-
-    bool operator==( ImageSubresourceLayers const& rhs ) const
-    {
-      return ( aspectMask == rhs.aspectMask )
-          && ( mipLevel == rhs.mipLevel )
-          && ( baseArrayLayer == rhs.baseArrayLayer )
-          && ( layerCount == rhs.layerCount );
-    }
-
-    bool operator!=( ImageSubresourceLayers const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageAspectFlags aspectMask;
-    uint32_t mipLevel;
-    uint32_t baseArrayLayer;
-    uint32_t layerCount;
-  };
-  static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" );
-
-  struct ImageSubresourceRange
-  {
-    ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
-                           uint32_t baseMipLevel_ = 0,
-                           uint32_t levelCount_ = 0,
-                           uint32_t baseArrayLayer_ = 0,
-                           uint32_t layerCount_ = 0 )
-      : aspectMask( aspectMask_ )
-      , baseMipLevel( baseMipLevel_ )
-      , levelCount( levelCount_ )
-      , baseArrayLayer( baseArrayLayer_ )
-      , layerCount( layerCount_ )
-    {
-    }
-
-    ImageSubresourceRange( VkImageSubresourceRange const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
-    }
-
-    ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
-      return *this;
-    }
-    ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ )
-    {
-      aspectMask = aspectMask_;
-      return *this;
-    }
-
-    ImageSubresourceRange& setBaseMipLevel( uint32_t baseMipLevel_ )
-    {
-      baseMipLevel = baseMipLevel_;
-      return *this;
-    }
-
-    ImageSubresourceRange& setLevelCount( uint32_t levelCount_ )
-    {
-      levelCount = levelCount_;
-      return *this;
-    }
-
-    ImageSubresourceRange& setBaseArrayLayer( uint32_t baseArrayLayer_ )
-    {
-      baseArrayLayer = baseArrayLayer_;
-      return *this;
-    }
-
-    ImageSubresourceRange& setLayerCount( uint32_t layerCount_ )
-    {
-      layerCount = layerCount_;
-      return *this;
-    }
-
-    operator VkImageSubresourceRange const&() const
-    {
-      return *reinterpret_cast<const VkImageSubresourceRange*>(this);
-    }
-
-    operator VkImageSubresourceRange &()
-    {
-      return *reinterpret_cast<VkImageSubresourceRange*>(this);
-    }
-
-    bool operator==( ImageSubresourceRange const& rhs ) const
-    {
-      return ( aspectMask == rhs.aspectMask )
-          && ( baseMipLevel == rhs.baseMipLevel )
-          && ( levelCount == rhs.levelCount )
-          && ( baseArrayLayer == rhs.baseArrayLayer )
-          && ( layerCount == rhs.layerCount );
-    }
-
-    bool operator!=( ImageSubresourceRange const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageAspectFlags aspectMask;
-    uint32_t baseMipLevel;
-    uint32_t levelCount;
-    uint32_t baseArrayLayer;
-    uint32_t layerCount;
-  };
-  static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" );
-
-  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() )
-      : srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
-      , oldLayout( oldLayout_ )
-      , newLayout( newLayout_ )
-      , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
-      , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
-      , image( image_ )
-      , subresourceRange( subresourceRange_ )
-    {
-    }
-
-    ImageMemoryBarrier( VkImageMemoryBarrier const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
-    }
-
-    ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
-      return *this;
-    }
-    ImageMemoryBarrier& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
-    {
-      srcAccessMask = srcAccessMask_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
-    {
-      dstAccessMask = dstAccessMask_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setOldLayout( ImageLayout oldLayout_ )
-    {
-      oldLayout = oldLayout_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setNewLayout( ImageLayout newLayout_ )
-    {
-      newLayout = newLayout_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
-    {
-      srcQueueFamilyIndex = srcQueueFamilyIndex_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
-    {
-      dstQueueFamilyIndex = dstQueueFamilyIndex_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
-    {
-      subresourceRange = subresourceRange_;
-      return *this;
-    }
-
-    operator VkImageMemoryBarrier const&() const
-    {
-      return *reinterpret_cast<const VkImageMemoryBarrier*>(this);
-    }
-
-    operator VkImageMemoryBarrier &()
-    {
-      return *reinterpret_cast<VkImageMemoryBarrier*>(this);
-    }
-
-    bool operator==( ImageMemoryBarrier const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( srcAccessMask == rhs.srcAccessMask )
-          && ( dstAccessMask == rhs.dstAccessMask )
-          && ( oldLayout == rhs.oldLayout )
-          && ( newLayout == rhs.newLayout )
-          && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
-          && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
-          && ( image == rhs.image )
-          && ( subresourceRange == rhs.subresourceRange );
-    }
-
-    bool operator!=( ImageMemoryBarrier const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageMemoryBarrier;
-
-  public:
-    const void* pNext = nullptr;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
-    ImageLayout oldLayout;
-    ImageLayout newLayout;
-    uint32_t srcQueueFamilyIndex;
-    uint32_t dstQueueFamilyIndex;
-    Image image;
-    ImageSubresourceRange subresourceRange;
-  };
-  static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" );
-
-  struct ImageViewCreateInfo
-  {
-    ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(),
-                         Image image_ = Image(),
-                         ImageViewType viewType_ = ImageViewType::e1D,
-                         Format format_ = Format::eUndefined,
-                         ComponentMapping components_ = ComponentMapping(),
-                         ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
-      : flags( flags_ )
-      , image( image_ )
-      , viewType( viewType_ )
-      , format( format_ )
-      , components( components_ )
-      , subresourceRange( subresourceRange_ )
-    {
-    }
-
-    ImageViewCreateInfo( VkImageViewCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
-    }
-
-    ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
-      return *this;
-    }
-    ImageViewCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageViewCreateInfo& setFlags( ImageViewCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ImageViewCreateInfo& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    ImageViewCreateInfo& setViewType( ImageViewType viewType_ )
-    {
-      viewType = viewType_;
-      return *this;
-    }
-
-    ImageViewCreateInfo& setFormat( Format format_ )
-    {
-      format = format_;
-      return *this;
-    }
-
-    ImageViewCreateInfo& setComponents( ComponentMapping components_ )
-    {
-      components = components_;
-      return *this;
-    }
-
-    ImageViewCreateInfo& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
-    {
-      subresourceRange = subresourceRange_;
-      return *this;
-    }
-
-    operator VkImageViewCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkImageViewCreateInfo*>(this);
-    }
-
-    operator VkImageViewCreateInfo &()
-    {
-      return *reinterpret_cast<VkImageViewCreateInfo*>(this);
-    }
-
-    bool operator==( ImageViewCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( image == rhs.image )
-          && ( viewType == rhs.viewType )
-          && ( format == rhs.format )
-          && ( components == rhs.components )
-          && ( subresourceRange == rhs.subresourceRange );
-    }
-
-    bool operator!=( ImageViewCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageViewCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ImageViewCreateFlags flags;
-    Image image;
-    ImageViewType viewType;
-    Format format;
-    ComponentMapping components;
-    ImageSubresourceRange subresourceRange;
-  };
-  static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" );
-
-  struct ImageCopy
-  {
-    ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
-               Offset3D srcOffset_ = Offset3D(),
-               ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
-               Offset3D dstOffset_ = Offset3D(),
-               Extent3D extent_ = Extent3D() )
-      : srcSubresource( srcSubresource_ )
-      , srcOffset( srcOffset_ )
-      , dstSubresource( dstSubresource_ )
-      , dstOffset( dstOffset_ )
-      , extent( extent_ )
-    {
-    }
-
-    ImageCopy( VkImageCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageCopy ) );
-    }
-
-    ImageCopy& operator=( VkImageCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageCopy ) );
-      return *this;
-    }
-    ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
-    {
-      srcSubresource = srcSubresource_;
-      return *this;
-    }
-
-    ImageCopy& setSrcOffset( Offset3D srcOffset_ )
-    {
-      srcOffset = srcOffset_;
-      return *this;
-    }
-
-    ImageCopy& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
-    {
-      dstSubresource = dstSubresource_;
-      return *this;
-    }
-
-    ImageCopy& setDstOffset( Offset3D dstOffset_ )
-    {
-      dstOffset = dstOffset_;
-      return *this;
-    }
-
-    ImageCopy& setExtent( Extent3D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    operator VkImageCopy const&() const
-    {
-      return *reinterpret_cast<const VkImageCopy*>(this);
-    }
-
-    operator VkImageCopy &()
-    {
-      return *reinterpret_cast<VkImageCopy*>(this);
-    }
-
-    bool operator==( ImageCopy const& rhs ) const
-    {
-      return ( srcSubresource == rhs.srcSubresource )
-          && ( srcOffset == rhs.srcOffset )
-          && ( dstSubresource == rhs.dstSubresource )
-          && ( dstOffset == rhs.dstOffset )
-          && ( extent == rhs.extent );
-    }
-
-    bool operator!=( ImageCopy const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageSubresourceLayers srcSubresource;
-    Offset3D srcOffset;
-    ImageSubresourceLayers dstSubresource;
-    Offset3D dstOffset;
-    Extent3D extent;
-  };
-  static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" );
-
-  struct ImageBlit
-  {
-    ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
-               std::array<Offset3D,2> const& srcOffsets_ = { { Offset3D(), Offset3D() } },
-               ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
-               std::array<Offset3D,2> const& dstOffsets_ = { { Offset3D(), Offset3D() } } )
-      : srcSubresource( srcSubresource_ )
-      , dstSubresource( dstSubresource_ )
-    {
-      memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
-      memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
-    }
-
-    ImageBlit( VkImageBlit const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageBlit ) );
-    }
-
-    ImageBlit& operator=( VkImageBlit const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageBlit ) );
-      return *this;
-    }
-    ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
-    {
-      srcSubresource = srcSubresource_;
-      return *this;
-    }
-
-    ImageBlit& setSrcOffsets( std::array<Offset3D,2> srcOffsets_ )
-    {
-      memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
-      return *this;
-    }
-
-    ImageBlit& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
-    {
-      dstSubresource = dstSubresource_;
-      return *this;
-    }
-
-    ImageBlit& setDstOffsets( std::array<Offset3D,2> dstOffsets_ )
-    {
-      memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
-      return *this;
-    }
-
-    operator VkImageBlit const&() const
-    {
-      return *reinterpret_cast<const VkImageBlit*>(this);
-    }
-
-    operator VkImageBlit &()
-    {
-      return *reinterpret_cast<VkImageBlit*>(this);
-    }
-
-    bool operator==( ImageBlit const& rhs ) const
-    {
-      return ( srcSubresource == rhs.srcSubresource )
-          && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 )
-          && ( dstSubresource == rhs.dstSubresource )
-          && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 );
-    }
-
-    bool operator!=( ImageBlit const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageSubresourceLayers srcSubresource;
-    Offset3D srcOffsets[2];
-    ImageSubresourceLayers dstSubresource;
-    Offset3D dstOffsets[2];
-  };
-  static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" );
-
-  struct BufferImageCopy
-  {
-    BufferImageCopy( DeviceSize bufferOffset_ = 0,
-                     uint32_t bufferRowLength_ = 0,
-                     uint32_t bufferImageHeight_ = 0,
-                     ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(),
-                     Offset3D imageOffset_ = Offset3D(),
-                     Extent3D imageExtent_ = Extent3D() )
-      : bufferOffset( bufferOffset_ )
-      , bufferRowLength( bufferRowLength_ )
-      , bufferImageHeight( bufferImageHeight_ )
-      , imageSubresource( imageSubresource_ )
-      , imageOffset( imageOffset_ )
-      , imageExtent( imageExtent_ )
-    {
-    }
-
-    BufferImageCopy( VkBufferImageCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferImageCopy ) );
-    }
-
-    BufferImageCopy& operator=( VkBufferImageCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferImageCopy ) );
-      return *this;
-    }
-    BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ )
-    {
-      bufferOffset = bufferOffset_;
-      return *this;
-    }
-
-    BufferImageCopy& setBufferRowLength( uint32_t bufferRowLength_ )
-    {
-      bufferRowLength = bufferRowLength_;
-      return *this;
-    }
-
-    BufferImageCopy& setBufferImageHeight( uint32_t bufferImageHeight_ )
-    {
-      bufferImageHeight = bufferImageHeight_;
-      return *this;
-    }
-
-    BufferImageCopy& setImageSubresource( ImageSubresourceLayers imageSubresource_ )
-    {
-      imageSubresource = imageSubresource_;
-      return *this;
-    }
-
-    BufferImageCopy& setImageOffset( Offset3D imageOffset_ )
-    {
-      imageOffset = imageOffset_;
-      return *this;
-    }
-
-    BufferImageCopy& setImageExtent( Extent3D imageExtent_ )
-    {
-      imageExtent = imageExtent_;
-      return *this;
-    }
-
-    operator VkBufferImageCopy const&() const
-    {
-      return *reinterpret_cast<const VkBufferImageCopy*>(this);
-    }
-
-    operator VkBufferImageCopy &()
-    {
-      return *reinterpret_cast<VkBufferImageCopy*>(this);
-    }
-
-    bool operator==( BufferImageCopy const& rhs ) const
-    {
-      return ( bufferOffset == rhs.bufferOffset )
-          && ( bufferRowLength == rhs.bufferRowLength )
-          && ( bufferImageHeight == rhs.bufferImageHeight )
-          && ( imageSubresource == rhs.imageSubresource )
-          && ( imageOffset == rhs.imageOffset )
-          && ( imageExtent == rhs.imageExtent );
-    }
-
-    bool operator!=( BufferImageCopy const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize bufferOffset;
-    uint32_t bufferRowLength;
-    uint32_t bufferImageHeight;
-    ImageSubresourceLayers imageSubresource;
-    Offset3D imageOffset;
-    Extent3D imageExtent;
-  };
-  static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" );
-
-  struct ImageResolve
-  {
-    ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
-                  Offset3D srcOffset_ = Offset3D(),
-                  ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
-                  Offset3D dstOffset_ = Offset3D(),
-                  Extent3D extent_ = Extent3D() )
-      : srcSubresource( srcSubresource_ )
-      , srcOffset( srcOffset_ )
-      , dstSubresource( dstSubresource_ )
-      , dstOffset( dstOffset_ )
-      , extent( extent_ )
-    {
-    }
-
-    ImageResolve( VkImageResolve const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageResolve ) );
-    }
-
-    ImageResolve& operator=( VkImageResolve const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageResolve ) );
-      return *this;
-    }
-    ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
-    {
-      srcSubresource = srcSubresource_;
-      return *this;
-    }
-
-    ImageResolve& setSrcOffset( Offset3D srcOffset_ )
-    {
-      srcOffset = srcOffset_;
-      return *this;
-    }
-
-    ImageResolve& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
-    {
-      dstSubresource = dstSubresource_;
-      return *this;
-    }
-
-    ImageResolve& setDstOffset( Offset3D dstOffset_ )
-    {
-      dstOffset = dstOffset_;
-      return *this;
-    }
-
-    ImageResolve& setExtent( Extent3D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    operator VkImageResolve const&() const
-    {
-      return *reinterpret_cast<const VkImageResolve*>(this);
-    }
-
-    operator VkImageResolve &()
-    {
-      return *reinterpret_cast<VkImageResolve*>(this);
-    }
-
-    bool operator==( ImageResolve const& rhs ) const
-    {
-      return ( srcSubresource == rhs.srcSubresource )
-          && ( srcOffset == rhs.srcOffset )
-          && ( dstSubresource == rhs.dstSubresource )
-          && ( dstOffset == rhs.dstOffset )
-          && ( extent == rhs.extent );
-    }
-
-    bool operator!=( ImageResolve const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageSubresourceLayers srcSubresource;
-    Offset3D srcOffset;
-    ImageSubresourceLayers dstSubresource;
-    Offset3D dstOffset;
-    Extent3D extent;
-  };
-  static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" );
-
-  struct ClearAttachment
-  {
-    ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
-                     uint32_t colorAttachment_ = 0,
-                     ClearValue clearValue_ = ClearValue() )
-      : aspectMask( aspectMask_ )
-      , colorAttachment( colorAttachment_ )
-      , clearValue( clearValue_ )
-    {
-    }
-
-    ClearAttachment( VkClearAttachment const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearAttachment ) );
-    }
-
-    ClearAttachment& operator=( VkClearAttachment const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearAttachment ) );
-      return *this;
-    }
-    ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ )
-    {
-      aspectMask = aspectMask_;
-      return *this;
-    }
-
-    ClearAttachment& setColorAttachment( uint32_t colorAttachment_ )
-    {
-      colorAttachment = colorAttachment_;
-      return *this;
-    }
-
-    ClearAttachment& setClearValue( ClearValue clearValue_ )
-    {
-      clearValue = clearValue_;
-      return *this;
-    }
-
-    operator VkClearAttachment const&() const
-    {
-      return *reinterpret_cast<const VkClearAttachment*>(this);
-    }
-
-    operator VkClearAttachment &()
-    {
-      return *reinterpret_cast<VkClearAttachment*>(this);
-    }
-
-    ImageAspectFlags aspectMask;
-    uint32_t colorAttachment;
-    ClearValue clearValue;
-  };
-  static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" );
-
-  struct InputAttachmentAspectReference
-  {
-    InputAttachmentAspectReference( uint32_t subpass_ = 0,
-                                    uint32_t inputAttachmentIndex_ = 0,
-                                    ImageAspectFlags aspectMask_ = ImageAspectFlags() )
-      : subpass( subpass_ )
-      , inputAttachmentIndex( inputAttachmentIndex_ )
-      , aspectMask( aspectMask_ )
-    {
-    }
-
-    InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) );
-    }
-
-    InputAttachmentAspectReference& operator=( VkInputAttachmentAspectReference const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) );
-      return *this;
-    }
-    InputAttachmentAspectReference& setSubpass( uint32_t subpass_ )
-    {
-      subpass = subpass_;
-      return *this;
-    }
-
-    InputAttachmentAspectReference& setInputAttachmentIndex( uint32_t inputAttachmentIndex_ )
-    {
-      inputAttachmentIndex = inputAttachmentIndex_;
-      return *this;
-    }
-
-    InputAttachmentAspectReference& setAspectMask( ImageAspectFlags aspectMask_ )
-    {
-      aspectMask = aspectMask_;
-      return *this;
-    }
-
-    operator VkInputAttachmentAspectReference const&() const
-    {
-      return *reinterpret_cast<const VkInputAttachmentAspectReference*>(this);
-    }
-
-    operator VkInputAttachmentAspectReference &()
-    {
-      return *reinterpret_cast<VkInputAttachmentAspectReference*>(this);
-    }
-
-    bool operator==( InputAttachmentAspectReference const& rhs ) const
-    {
-      return ( subpass == rhs.subpass )
-          && ( inputAttachmentIndex == rhs.inputAttachmentIndex )
-          && ( aspectMask == rhs.aspectMask );
-    }
-
-    bool operator!=( InputAttachmentAspectReference const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t subpass;
-    uint32_t inputAttachmentIndex;
-    ImageAspectFlags aspectMask;
-  };
-  static_assert( sizeof( InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), "struct and wrapper have different size!" );
-
-  using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
-
-  struct RenderPassInputAttachmentAspectCreateInfo
-  {
-    RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0,
-                                               const InputAttachmentAspectReference* pAspectReferences_ = nullptr )
-      : aspectReferenceCount( aspectReferenceCount_ )
-      , pAspectReferences( pAspectReferences_ )
-    {
-    }
-
-    RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) );
-    }
-
-    RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) );
-      return *this;
-    }
-    RenderPassInputAttachmentAspectCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    RenderPassInputAttachmentAspectCreateInfo& setAspectReferenceCount( uint32_t aspectReferenceCount_ )
-    {
-      aspectReferenceCount = aspectReferenceCount_;
-      return *this;
-    }
-
-    RenderPassInputAttachmentAspectCreateInfo& setPAspectReferences( const InputAttachmentAspectReference* pAspectReferences_ )
-    {
-      pAspectReferences = pAspectReferences_;
-      return *this;
-    }
-
-    operator VkRenderPassInputAttachmentAspectCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(this);
-    }
-
-    operator VkRenderPassInputAttachmentAspectCreateInfo &()
-    {
-      return *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(this);
-    }
-
-    bool operator==( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( aspectReferenceCount == rhs.aspectReferenceCount )
-          && ( pAspectReferences == rhs.pAspectReferences );
-    }
-
-    bool operator!=( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t aspectReferenceCount;
-    const InputAttachmentAspectReference* pAspectReferences;
-  };
-  static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" );
-
-  using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
-
-  struct BindImagePlaneMemoryInfo
-  {
-    BindImagePlaneMemoryInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
-      : planeAspect( planeAspect_ )
-    {
-    }
-
-    BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) );
-    }
-
-    BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) );
-      return *this;
-    }
-    BindImagePlaneMemoryInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindImagePlaneMemoryInfo& setPlaneAspect( ImageAspectFlagBits planeAspect_ )
-    {
-      planeAspect = planeAspect_;
-      return *this;
-    }
-
-    operator VkBindImagePlaneMemoryInfo const&() const
-    {
-      return *reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(this);
-    }
-
-    operator VkBindImagePlaneMemoryInfo &()
-    {
-      return *reinterpret_cast<VkBindImagePlaneMemoryInfo*>(this);
-    }
-
-    bool operator==( BindImagePlaneMemoryInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( planeAspect == rhs.planeAspect );
-    }
-
-    bool operator!=( BindImagePlaneMemoryInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindImagePlaneMemoryInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ImageAspectFlagBits planeAspect;
-  };
-  static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "struct and wrapper have different size!" );
-
-  using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
-
-  struct ImagePlaneMemoryRequirementsInfo
-  {
-    ImagePlaneMemoryRequirementsInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
-      : planeAspect( planeAspect_ )
-    {
-    }
-
-    ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) );
-    }
-
-    ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) );
-      return *this;
-    }
-    ImagePlaneMemoryRequirementsInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImagePlaneMemoryRequirementsInfo& setPlaneAspect( ImageAspectFlagBits planeAspect_ )
-    {
-      planeAspect = planeAspect_;
-      return *this;
-    }
-
-    operator VkImagePlaneMemoryRequirementsInfo const&() const
-    {
-      return *reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(this);
-    }
-
-    operator VkImagePlaneMemoryRequirementsInfo &()
-    {
-      return *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(this);
-    }
-
-    bool operator==( ImagePlaneMemoryRequirementsInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( planeAspect == rhs.planeAspect );
-    }
-
-    bool operator!=( ImagePlaneMemoryRequirementsInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ImageAspectFlagBits planeAspect;
-  };
-  static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "struct and wrapper have different size!" );
-
-  using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
-
-  struct AttachmentReference2KHR
-  {
-    AttachmentReference2KHR( uint32_t attachment_ = 0,
-                             ImageLayout layout_ = ImageLayout::eUndefined,
-                             ImageAspectFlags aspectMask_ = ImageAspectFlags() )
-      : attachment( attachment_ )
-      , layout( layout_ )
-      , aspectMask( aspectMask_ )
-    {
-    }
-
-    AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) );
-    }
-
-    AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) );
-      return *this;
-    }
-    AttachmentReference2KHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    AttachmentReference2KHR& setAttachment( uint32_t attachment_ )
-    {
-      attachment = attachment_;
-      return *this;
-    }
-
-    AttachmentReference2KHR& setLayout( ImageLayout layout_ )
-    {
-      layout = layout_;
-      return *this;
-    }
-
-    AttachmentReference2KHR& setAspectMask( ImageAspectFlags aspectMask_ )
-    {
-      aspectMask = aspectMask_;
-      return *this;
-    }
-
-    operator VkAttachmentReference2KHR const&() const
-    {
-      return *reinterpret_cast<const VkAttachmentReference2KHR*>(this);
-    }
-
-    operator VkAttachmentReference2KHR &()
-    {
-      return *reinterpret_cast<VkAttachmentReference2KHR*>(this);
-    }
-
-    bool operator==( AttachmentReference2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( attachment == rhs.attachment )
-          && ( layout == rhs.layout )
-          && ( aspectMask == rhs.aspectMask );
-    }
-
-    bool operator!=( AttachmentReference2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eAttachmentReference2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t attachment;
-    ImageLayout layout;
-    ImageAspectFlags aspectMask;
-  };
-  static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "struct and wrapper have different size!" );
-
-  enum class SparseImageFormatFlagBits
-  {
-    eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT,
-    eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT,
-    eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT
-  };
-
-  using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits, VkSparseImageFormatFlags>;
-
-  VULKAN_HPP_INLINE SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
-  {
-    return SparseImageFormatFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits )
-  {
-    return ~( SparseImageFormatFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<SparseImageFormatFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) | VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) | VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize)
-    };
-  };
-
-  struct SparseImageFormatProperties
-  {
-    operator VkSparseImageFormatProperties const&() const
-    {
-      return *reinterpret_cast<const VkSparseImageFormatProperties*>(this);
-    }
-
-    operator VkSparseImageFormatProperties &()
-    {
-      return *reinterpret_cast<VkSparseImageFormatProperties*>(this);
-    }
-
-    bool operator==( SparseImageFormatProperties const& rhs ) const
-    {
-      return ( aspectMask == rhs.aspectMask )
-          && ( imageGranularity == rhs.imageGranularity )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( SparseImageFormatProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageAspectFlags aspectMask;
-    Extent3D imageGranularity;
-    SparseImageFormatFlags flags;
-  };
-  static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" );
-
-  struct SparseImageMemoryRequirements
-  {
-    operator VkSparseImageMemoryRequirements const&() const
-    {
-      return *reinterpret_cast<const VkSparseImageMemoryRequirements*>(this);
-    }
-
-    operator VkSparseImageMemoryRequirements &()
-    {
-      return *reinterpret_cast<VkSparseImageMemoryRequirements*>(this);
-    }
-
-    bool operator==( SparseImageMemoryRequirements const& rhs ) const
-    {
-      return ( formatProperties == rhs.formatProperties )
-          && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod )
-          && ( imageMipTailSize == rhs.imageMipTailSize )
-          && ( imageMipTailOffset == rhs.imageMipTailOffset )
-          && ( imageMipTailStride == rhs.imageMipTailStride );
-    }
-
-    bool operator!=( SparseImageMemoryRequirements const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    SparseImageFormatProperties formatProperties;
-    uint32_t imageMipTailFirstLod;
-    DeviceSize imageMipTailSize;
-    DeviceSize imageMipTailOffset;
-    DeviceSize imageMipTailStride;
-  };
-  static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" );
-
-  struct SparseImageFormatProperties2
-  {
-    operator VkSparseImageFormatProperties2 const&() const
-    {
-      return *reinterpret_cast<const VkSparseImageFormatProperties2*>(this);
-    }
-
-    operator VkSparseImageFormatProperties2 &()
-    {
-      return *reinterpret_cast<VkSparseImageFormatProperties2*>(this);
-    }
-
-    bool operator==( SparseImageFormatProperties2 const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( properties == rhs.properties );
-    }
-
-    bool operator!=( SparseImageFormatProperties2 const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSparseImageFormatProperties2;
-
-  public:
-    void* pNext = nullptr;
-    SparseImageFormatProperties properties;
-  };
-  static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "struct and wrapper have different size!" );
-
-  using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
-
-  struct SparseImageMemoryRequirements2
-  {
-    operator VkSparseImageMemoryRequirements2 const&() const
-    {
-      return *reinterpret_cast<const VkSparseImageMemoryRequirements2*>(this);
-    }
-
-    operator VkSparseImageMemoryRequirements2 &()
-    {
-      return *reinterpret_cast<VkSparseImageMemoryRequirements2*>(this);
-    }
-
-    bool operator==( SparseImageMemoryRequirements2 const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memoryRequirements == rhs.memoryRequirements );
-    }
-
-    bool operator!=( SparseImageMemoryRequirements2 const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSparseImageMemoryRequirements2;
-
-  public:
-    void* pNext = nullptr;
-    SparseImageMemoryRequirements memoryRequirements;
-  };
-  static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" );
-
-  using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
-
-  enum class SparseMemoryBindFlagBits
-  {
-    eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT
-  };
-
-  using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits, VkSparseMemoryBindFlags>;
-
-  VULKAN_HPP_INLINE SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
-  {
-    return SparseMemoryBindFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits )
-  {
-    return ~( SparseMemoryBindFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<SparseMemoryBindFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata)
-    };
-  };
-
-  struct SparseMemoryBind
-  {
-    SparseMemoryBind( DeviceSize resourceOffset_ = 0,
-                      DeviceSize size_ = 0,
-                      DeviceMemory memory_ = DeviceMemory(),
-                      DeviceSize memoryOffset_ = 0,
-                      SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
-      : resourceOffset( resourceOffset_ )
-      , size( size_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
-      , flags( flags_ )
-    {
-    }
-
-    SparseMemoryBind( VkSparseMemoryBind const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
-    }
-
-    SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
-      return *this;
-    }
-    SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ )
-    {
-      resourceOffset = resourceOffset_;
-      return *this;
-    }
-
-    SparseMemoryBind& setSize( DeviceSize size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    SparseMemoryBind& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    SparseMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
-    {
-      memoryOffset = memoryOffset_;
-      return *this;
-    }
-
-    SparseMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator VkSparseMemoryBind const&() const
-    {
-      return *reinterpret_cast<const VkSparseMemoryBind*>(this);
-    }
-
-    operator VkSparseMemoryBind &()
-    {
-      return *reinterpret_cast<VkSparseMemoryBind*>(this);
-    }
-
-    bool operator==( SparseMemoryBind const& rhs ) const
-    {
-      return ( resourceOffset == rhs.resourceOffset )
-          && ( size == rhs.size )
-          && ( memory == rhs.memory )
-          && ( memoryOffset == rhs.memoryOffset )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( SparseMemoryBind const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize resourceOffset;
-    DeviceSize size;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
-    SparseMemoryBindFlags flags;
-  };
-  static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" );
-
-  struct SparseImageMemoryBind
-  {
-    SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(),
-                           Offset3D offset_ = Offset3D(),
-                           Extent3D extent_ = Extent3D(),
-                           DeviceMemory memory_ = DeviceMemory(),
-                           DeviceSize memoryOffset_ = 0,
-                           SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
-      : subresource( subresource_ )
-      , offset( offset_ )
-      , extent( extent_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
-      , flags( flags_ )
-    {
-    }
-
-    SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
-    }
-
-    SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
-      return *this;
-    }
-    SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ )
-    {
-      subresource = subresource_;
-      return *this;
-    }
-
-    SparseImageMemoryBind& setOffset( Offset3D offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    SparseImageMemoryBind& setExtent( Extent3D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    SparseImageMemoryBind& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    SparseImageMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
-    {
-      memoryOffset = memoryOffset_;
-      return *this;
-    }
-
-    SparseImageMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator VkSparseImageMemoryBind const&() const
-    {
-      return *reinterpret_cast<const VkSparseImageMemoryBind*>(this);
-    }
-
-    operator VkSparseImageMemoryBind &()
-    {
-      return *reinterpret_cast<VkSparseImageMemoryBind*>(this);
-    }
-
-    bool operator==( SparseImageMemoryBind const& rhs ) const
-    {
-      return ( subresource == rhs.subresource )
-          && ( offset == rhs.offset )
-          && ( extent == rhs.extent )
-          && ( memory == rhs.memory )
-          && ( memoryOffset == rhs.memoryOffset )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( SparseImageMemoryBind const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageSubresource subresource;
-    Offset3D offset;
-    Extent3D extent;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
-    SparseMemoryBindFlags flags;
-  };
-  static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" );
-
-  struct SparseBufferMemoryBindInfo
-  {
-    SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(),
-                                uint32_t bindCount_ = 0,
-                                const SparseMemoryBind* pBinds_ = nullptr )
-      : buffer( buffer_ )
-      , bindCount( bindCount_ )
-      , pBinds( pBinds_ )
-    {
-    }
-
-    SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
-    }
-
-    SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
-      return *this;
-    }
-    SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    SparseBufferMemoryBindInfo& setBindCount( uint32_t bindCount_ )
-    {
-      bindCount = bindCount_;
-      return *this;
-    }
-
-    SparseBufferMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
-    {
-      pBinds = pBinds_;
-      return *this;
-    }
-
-    operator VkSparseBufferMemoryBindInfo const&() const
-    {
-      return *reinterpret_cast<const VkSparseBufferMemoryBindInfo*>(this);
-    }
-
-    operator VkSparseBufferMemoryBindInfo &()
-    {
-      return *reinterpret_cast<VkSparseBufferMemoryBindInfo*>(this);
-    }
-
-    bool operator==( SparseBufferMemoryBindInfo const& rhs ) const
-    {
-      return ( buffer == rhs.buffer )
-          && ( bindCount == rhs.bindCount )
-          && ( pBinds == rhs.pBinds );
-    }
-
-    bool operator!=( SparseBufferMemoryBindInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Buffer buffer;
-    uint32_t bindCount;
-    const SparseMemoryBind* pBinds;
-  };
-  static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" );
-
-  struct SparseImageOpaqueMemoryBindInfo
-  {
-    SparseImageOpaqueMemoryBindInfo( Image image_ = Image(),
-                                     uint32_t bindCount_ = 0,
-                                     const SparseMemoryBind* pBinds_ = nullptr )
-      : image( image_ )
-      , bindCount( bindCount_ )
-      , pBinds( pBinds_ )
-    {
-    }
-
-    SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
-    }
-
-    SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
-      return *this;
-    }
-    SparseImageOpaqueMemoryBindInfo& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    SparseImageOpaqueMemoryBindInfo& setBindCount( uint32_t bindCount_ )
-    {
-      bindCount = bindCount_;
-      return *this;
-    }
-
-    SparseImageOpaqueMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
-    {
-      pBinds = pBinds_;
-      return *this;
-    }
-
-    operator VkSparseImageOpaqueMemoryBindInfo const&() const
-    {
-      return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>(this);
-    }
-
-    operator VkSparseImageOpaqueMemoryBindInfo &()
-    {
-      return *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>(this);
-    }
-
-    bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const
-    {
-      return ( image == rhs.image )
-          && ( bindCount == rhs.bindCount )
-          && ( pBinds == rhs.pBinds );
-    }
-
-    bool operator!=( SparseImageOpaqueMemoryBindInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Image image;
-    uint32_t bindCount;
-    const SparseMemoryBind* pBinds;
-  };
-  static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" );
-
-  struct SparseImageMemoryBindInfo
-  {
-    SparseImageMemoryBindInfo( Image image_ = Image(),
-                               uint32_t bindCount_ = 0,
-                               const SparseImageMemoryBind* pBinds_ = nullptr )
-      : image( image_ )
-      , bindCount( bindCount_ )
-      , pBinds( pBinds_ )
-    {
-    }
-
-    SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
-    }
-
-    SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
-      return *this;
-    }
-    SparseImageMemoryBindInfo& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    SparseImageMemoryBindInfo& setBindCount( uint32_t bindCount_ )
-    {
-      bindCount = bindCount_;
-      return *this;
-    }
-
-    SparseImageMemoryBindInfo& setPBinds( const SparseImageMemoryBind* pBinds_ )
-    {
-      pBinds = pBinds_;
-      return *this;
-    }
-
-    operator VkSparseImageMemoryBindInfo const&() const
-    {
-      return *reinterpret_cast<const VkSparseImageMemoryBindInfo*>(this);
-    }
-
-    operator VkSparseImageMemoryBindInfo &()
-    {
-      return *reinterpret_cast<VkSparseImageMemoryBindInfo*>(this);
-    }
-
-    bool operator==( SparseImageMemoryBindInfo const& rhs ) const
-    {
-      return ( image == rhs.image )
-          && ( bindCount == rhs.bindCount )
-          && ( pBinds == rhs.pBinds );
-    }
-
-    bool operator!=( SparseImageMemoryBindInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Image image;
-    uint32_t bindCount;
-    const SparseImageMemoryBind* pBinds;
-  };
-  static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" );
-
-  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 )
-      : waitSemaphoreCount( waitSemaphoreCount_ )
-      , pWaitSemaphores( pWaitSemaphores_ )
-      , bufferBindCount( bufferBindCount_ )
-      , pBufferBinds( pBufferBinds_ )
-      , imageOpaqueBindCount( imageOpaqueBindCount_ )
-      , pImageOpaqueBinds( pImageOpaqueBinds_ )
-      , imageBindCount( imageBindCount_ )
-      , pImageBinds( pImageBinds_ )
-      , signalSemaphoreCount( signalSemaphoreCount_ )
-      , pSignalSemaphores( pSignalSemaphores_ )
-    {
-    }
-
-    BindSparseInfo( VkBindSparseInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindSparseInfo ) );
-    }
-
-    BindSparseInfo& operator=( VkBindSparseInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindSparseInfo ) );
-      return *this;
-    }
-    BindSparseInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindSparseInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
-    {
-      waitSemaphoreCount = waitSemaphoreCount_;
-      return *this;
-    }
-
-    BindSparseInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
-    {
-      pWaitSemaphores = pWaitSemaphores_;
-      return *this;
-    }
-
-    BindSparseInfo& setBufferBindCount( uint32_t bufferBindCount_ )
-    {
-      bufferBindCount = bufferBindCount_;
-      return *this;
-    }
-
-    BindSparseInfo& setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ )
-    {
-      pBufferBinds = pBufferBinds_;
-      return *this;
-    }
-
-    BindSparseInfo& setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ )
-    {
-      imageOpaqueBindCount = imageOpaqueBindCount_;
-      return *this;
-    }
-
-    BindSparseInfo& setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ )
-    {
-      pImageOpaqueBinds = pImageOpaqueBinds_;
-      return *this;
-    }
-
-    BindSparseInfo& setImageBindCount( uint32_t imageBindCount_ )
-    {
-      imageBindCount = imageBindCount_;
-      return *this;
-    }
-
-    BindSparseInfo& setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ )
-    {
-      pImageBinds = pImageBinds_;
-      return *this;
-    }
-
-    BindSparseInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
-    {
-      signalSemaphoreCount = signalSemaphoreCount_;
-      return *this;
-    }
-
-    BindSparseInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
-    {
-      pSignalSemaphores = pSignalSemaphores_;
-      return *this;
-    }
-
-    operator VkBindSparseInfo const&() const
-    {
-      return *reinterpret_cast<const VkBindSparseInfo*>(this);
-    }
-
-    operator VkBindSparseInfo &()
-    {
-      return *reinterpret_cast<VkBindSparseInfo*>(this);
-    }
-
-    bool operator==( BindSparseInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
-          && ( pWaitSemaphores == rhs.pWaitSemaphores )
-          && ( bufferBindCount == rhs.bufferBindCount )
-          && ( pBufferBinds == rhs.pBufferBinds )
-          && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount )
-          && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds )
-          && ( imageBindCount == rhs.imageBindCount )
-          && ( pImageBinds == rhs.pImageBinds )
-          && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
-          && ( pSignalSemaphores == rhs.pSignalSemaphores );
-    }
-
-    bool operator!=( BindSparseInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindSparseInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreCount;
-    const Semaphore* pWaitSemaphores;
-    uint32_t bufferBindCount;
-    const SparseBufferMemoryBindInfo* pBufferBinds;
-    uint32_t imageOpaqueBindCount;
-    const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
-    uint32_t imageBindCount;
-    const SparseImageMemoryBindInfo* pImageBinds;
-    uint32_t signalSemaphoreCount;
-    const Semaphore* pSignalSemaphores;
-  };
-  static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" );
-
-  enum class PipelineStageFlagBits
-  {
-    eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-    eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
-    eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
-    eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
-    eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT,
-    eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT,
-    eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
-    eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-    eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
-    eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
-    eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-    eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-    eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT,
-    eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
-    eHost = VK_PIPELINE_STAGE_HOST_BIT,
-    eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
-    eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-    eTransformFeedbackEXT = VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT,
-    eConditionalRenderingEXT = VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT,
-    eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX,
-    eShadingRateImageNV = VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV,
-    eRayTracingShaderNV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV,
-    eAccelerationStructureBuildNV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV,
-    eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV,
-    eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV,
-    eFragmentDensityProcessEXT = VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT
-  };
-
-  using PipelineStageFlags = Flags<PipelineStageFlagBits, VkPipelineStageFlags>;
-
-  VULKAN_HPP_INLINE PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
-  {
-    return PipelineStageFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE PipelineStageFlags operator~( PipelineStageFlagBits bits )
-  {
-    return ~( PipelineStageFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<PipelineStageFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eTransformFeedbackEXT) | VkFlags(PipelineStageFlagBits::eConditionalRenderingEXT) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) | VkFlags(PipelineStageFlagBits::eShadingRateImageNV) | VkFlags(PipelineStageFlagBits::eRayTracingShaderNV) | VkFlags(PipelineStageFlagBits::eAccelerationStructureBuildNV) | VkFlags(PipelineStageFlagBits::eTaskShaderNV) | VkFlags(PipelineStageFlagBits::eMeshShaderNV) | VkFlags(PipelineStageFlagBits::eFragmentDensityProcessEXT)
-    };
-  };
-
-  struct QueueFamilyCheckpointPropertiesNV
-  {
-    operator VkQueueFamilyCheckpointPropertiesNV const&() const
-    {
-      return *reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(this);
-    }
-
-    operator VkQueueFamilyCheckpointPropertiesNV &()
-    {
-      return *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this);
-    }
-
-    bool operator==( QueueFamilyCheckpointPropertiesNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask );
-    }
-
-    bool operator!=( QueueFamilyCheckpointPropertiesNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV;
-
-  public:
-    void* pNext = nullptr;
-    PipelineStageFlags checkpointExecutionStageMask;
-  };
-  static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "struct and wrapper have different size!" );
-
-  struct CheckpointDataNV
-  {
-    operator VkCheckpointDataNV const&() const
-    {
-      return *reinterpret_cast<const VkCheckpointDataNV*>(this);
-    }
-
-    operator VkCheckpointDataNV &()
-    {
-      return *reinterpret_cast<VkCheckpointDataNV*>(this);
-    }
-
-    bool operator==( CheckpointDataNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( stage == rhs.stage )
-          && ( pCheckpointMarker == rhs.pCheckpointMarker );
-    }
-
-    bool operator!=( CheckpointDataNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCheckpointDataNV;
-
-  public:
-    void* pNext = nullptr;
-    PipelineStageFlagBits stage;
-    void* pCheckpointMarker;
-  };
-  static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "struct and wrapper have different size!" );
-
-  enum class CommandPoolCreateFlagBits
-  {
-    eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
-    eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
-    eProtected = VK_COMMAND_POOL_CREATE_PROTECTED_BIT
-  };
-
-  using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits, VkCommandPoolCreateFlags>;
-
-  VULKAN_HPP_INLINE CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
-  {
-    return CommandPoolCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits )
-  {
-    return ~( CommandPoolCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<CommandPoolCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) | VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer) | VkFlags(CommandPoolCreateFlagBits::eProtected)
-    };
-  };
-
-  struct CommandPoolCreateInfo
-  {
-    CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(),
-                           uint32_t queueFamilyIndex_ = 0 )
-      : flags( flags_ )
-      , queueFamilyIndex( queueFamilyIndex_ )
-    {
-    }
-
-    CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
-    }
-
-    CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
-      return *this;
-    }
-    CommandPoolCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CommandPoolCreateInfo& setFlags( CommandPoolCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    CommandPoolCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
-    {
-      queueFamilyIndex = queueFamilyIndex_;
-      return *this;
-    }
-
-    operator VkCommandPoolCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkCommandPoolCreateInfo*>(this);
-    }
-
-    operator VkCommandPoolCreateInfo &()
-    {
-      return *reinterpret_cast<VkCommandPoolCreateInfo*>(this);
-    }
-
-    bool operator==( CommandPoolCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( queueFamilyIndex == rhs.queueFamilyIndex );
-    }
-
-    bool operator!=( CommandPoolCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCommandPoolCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    CommandPoolCreateFlags flags;
-    uint32_t queueFamilyIndex;
-  };
-  static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class CommandPoolResetFlagBits
-  {
-    eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
-  };
-
-  using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits, VkCommandPoolResetFlags>;
-
-  VULKAN_HPP_INLINE CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
-  {
-    return CommandPoolResetFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits )
-  {
-    return ~( CommandPoolResetFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<CommandPoolResetFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources)
-    };
-  };
-
-  enum class CommandBufferResetFlagBits
-  {
-    eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
-  };
-
-  using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits, VkCommandBufferResetFlags>;
-
-  VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
-  {
-    return CommandBufferResetFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits )
-  {
-    return ~( CommandBufferResetFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<CommandBufferResetFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources)
-    };
-  };
-
-  enum class SampleCountFlagBits
-  {
-    e1 = VK_SAMPLE_COUNT_1_BIT,
-    e2 = VK_SAMPLE_COUNT_2_BIT,
-    e4 = VK_SAMPLE_COUNT_4_BIT,
-    e8 = VK_SAMPLE_COUNT_8_BIT,
-    e16 = VK_SAMPLE_COUNT_16_BIT,
-    e32 = VK_SAMPLE_COUNT_32_BIT,
-    e64 = VK_SAMPLE_COUNT_64_BIT
-  };
-
-  using SampleCountFlags = Flags<SampleCountFlagBits, VkSampleCountFlags>;
-
-  VULKAN_HPP_INLINE SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
-  {
-    return SampleCountFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SampleCountFlags operator~( SampleCountFlagBits bits )
-  {
-    return ~( SampleCountFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<SampleCountFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) | VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) | VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) | VkFlags(SampleCountFlagBits::e64)
-    };
-  };
-
-  struct ImageFormatProperties
-  {
-    operator VkImageFormatProperties const&() const
-    {
-      return *reinterpret_cast<const VkImageFormatProperties*>(this);
-    }
-
-    operator VkImageFormatProperties &()
-    {
-      return *reinterpret_cast<VkImageFormatProperties*>(this);
-    }
-
-    bool operator==( ImageFormatProperties const& rhs ) const
-    {
-      return ( maxExtent == rhs.maxExtent )
-          && ( maxMipLevels == rhs.maxMipLevels )
-          && ( maxArrayLayers == rhs.maxArrayLayers )
-          && ( sampleCounts == rhs.sampleCounts )
-          && ( maxResourceSize == rhs.maxResourceSize );
-    }
-
-    bool operator!=( ImageFormatProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Extent3D maxExtent;
-    uint32_t maxMipLevels;
-    uint32_t maxArrayLayers;
-    SampleCountFlags sampleCounts;
-    DeviceSize maxResourceSize;
-  };
-  static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" );
-
-  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 )
-      : flags( flags_ )
-      , imageType( imageType_ )
-      , format( format_ )
-      , extent( extent_ )
-      , mipLevels( mipLevels_ )
-      , arrayLayers( arrayLayers_ )
-      , samples( samples_ )
-      , tiling( tiling_ )
-      , usage( usage_ )
-      , sharingMode( sharingMode_ )
-      , queueFamilyIndexCount( queueFamilyIndexCount_ )
-      , pQueueFamilyIndices( pQueueFamilyIndices_ )
-      , initialLayout( initialLayout_ )
-    {
-    }
-
-    ImageCreateInfo( VkImageCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
-    }
-
-    ImageCreateInfo& operator=( VkImageCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
-      return *this;
-    }
-    ImageCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageCreateInfo& setFlags( ImageCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ImageCreateInfo& setImageType( ImageType imageType_ )
-    {
-      imageType = imageType_;
-      return *this;
-    }
-
-    ImageCreateInfo& setFormat( Format format_ )
-    {
-      format = format_;
-      return *this;
-    }
-
-    ImageCreateInfo& setExtent( Extent3D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    ImageCreateInfo& setMipLevels( uint32_t mipLevels_ )
-    {
-      mipLevels = mipLevels_;
-      return *this;
-    }
-
-    ImageCreateInfo& setArrayLayers( uint32_t arrayLayers_ )
-    {
-      arrayLayers = arrayLayers_;
-      return *this;
-    }
-
-    ImageCreateInfo& setSamples( SampleCountFlagBits samples_ )
-    {
-      samples = samples_;
-      return *this;
-    }
-
-    ImageCreateInfo& setTiling( ImageTiling tiling_ )
-    {
-      tiling = tiling_;
-      return *this;
-    }
-
-    ImageCreateInfo& setUsage( ImageUsageFlags usage_ )
-    {
-      usage = usage_;
-      return *this;
-    }
-
-    ImageCreateInfo& setSharingMode( SharingMode sharingMode_ )
-    {
-      sharingMode = sharingMode_;
-      return *this;
-    }
-
-    ImageCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
-    {
-      queueFamilyIndexCount = queueFamilyIndexCount_;
-      return *this;
-    }
-
-    ImageCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
-    {
-      pQueueFamilyIndices = pQueueFamilyIndices_;
-      return *this;
-    }
-
-    ImageCreateInfo& setInitialLayout( ImageLayout initialLayout_ )
-    {
-      initialLayout = initialLayout_;
-      return *this;
-    }
-
-    operator VkImageCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkImageCreateInfo*>(this);
-    }
-
-    operator VkImageCreateInfo &()
-    {
-      return *reinterpret_cast<VkImageCreateInfo*>(this);
-    }
-
-    bool operator==( ImageCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( imageType == rhs.imageType )
-          && ( format == rhs.format )
-          && ( extent == rhs.extent )
-          && ( mipLevels == rhs.mipLevels )
-          && ( arrayLayers == rhs.arrayLayers )
-          && ( samples == rhs.samples )
-          && ( tiling == rhs.tiling )
-          && ( usage == rhs.usage )
-          && ( sharingMode == rhs.sharingMode )
-          && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
-          && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
-          && ( initialLayout == rhs.initialLayout );
-    }
-
-    bool operator!=( ImageCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ImageCreateFlags flags;
-    ImageType imageType;
-    Format format;
-    Extent3D extent;
-    uint32_t mipLevels;
-    uint32_t arrayLayers;
-    SampleCountFlagBits samples;
-    ImageTiling tiling;
-    ImageUsageFlags usage;
-    SharingMode sharingMode;
-    uint32_t queueFamilyIndexCount;
-    const uint32_t* pQueueFamilyIndices;
-    ImageLayout initialLayout;
-  };
-  static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" );
-
-  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 )
-      : flags( flags_ )
-      , rasterizationSamples( rasterizationSamples_ )
-      , sampleShadingEnable( sampleShadingEnable_ )
-      , minSampleShading( minSampleShading_ )
-      , pSampleMask( pSampleMask_ )
-      , alphaToCoverageEnable( alphaToCoverageEnable_ )
-      , alphaToOneEnable( alphaToOneEnable_ )
-    {
-    }
-
-    PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
-    }
-
-    PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
-      return *this;
-    }
-    PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setFlags( PipelineMultisampleStateCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ )
-    {
-      rasterizationSamples = rasterizationSamples_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setSampleShadingEnable( Bool32 sampleShadingEnable_ )
-    {
-      sampleShadingEnable = sampleShadingEnable_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setMinSampleShading( float minSampleShading_ )
-    {
-      minSampleShading = minSampleShading_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setPSampleMask( const SampleMask* pSampleMask_ )
-    {
-      pSampleMask = pSampleMask_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ )
-    {
-      alphaToCoverageEnable = alphaToCoverageEnable_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setAlphaToOneEnable( Bool32 alphaToOneEnable_ )
-    {
-      alphaToOneEnable = alphaToOneEnable_;
-      return *this;
-    }
-
-    operator VkPipelineMultisampleStateCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(this);
-    }
-
-    operator VkPipelineMultisampleStateCreateInfo &()
-    {
-      return *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( rasterizationSamples == rhs.rasterizationSamples )
-          && ( sampleShadingEnable == rhs.sampleShadingEnable )
-          && ( minSampleShading == rhs.minSampleShading )
-          && ( pSampleMask == rhs.pSampleMask )
-          && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable )
-          && ( alphaToOneEnable == rhs.alphaToOneEnable );
-    }
-
-    bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineMultisampleStateCreateFlags flags;
-    SampleCountFlagBits rasterizationSamples;
-    Bool32 sampleShadingEnable;
-    float minSampleShading;
-    const SampleMask* pSampleMask;
-    Bool32 alphaToCoverageEnable;
-    Bool32 alphaToOneEnable;
-  };
-  static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" );
-
-  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 )
-      : flags( flags_ )
-      , stageCount( stageCount_ )
-      , pStages( pStages_ )
-      , pVertexInputState( pVertexInputState_ )
-      , pInputAssemblyState( pInputAssemblyState_ )
-      , pTessellationState( pTessellationState_ )
-      , pViewportState( pViewportState_ )
-      , pRasterizationState( pRasterizationState_ )
-      , pMultisampleState( pMultisampleState_ )
-      , pDepthStencilState( pDepthStencilState_ )
-      , pColorBlendState( pColorBlendState_ )
-      , pDynamicState( pDynamicState_ )
-      , layout( layout_ )
-      , renderPass( renderPass_ )
-      , subpass( subpass_ )
-      , basePipelineHandle( basePipelineHandle_ )
-      , basePipelineIndex( basePipelineIndex_ )
-    {
-    }
-
-    GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
-    }
-
-    GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
-      return *this;
-    }
-    GraphicsPipelineCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setStageCount( uint32_t stageCount_ )
-    {
-      stageCount = stageCount_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPStages( const PipelineShaderStageCreateInfo* pStages_ )
-    {
-      pStages = pStages_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ )
-    {
-      pVertexInputState = pVertexInputState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ )
-    {
-      pInputAssemblyState = pInputAssemblyState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ )
-    {
-      pTessellationState = pTessellationState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ )
-    {
-      pViewportState = pViewportState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ )
-    {
-      pRasterizationState = pRasterizationState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ )
-    {
-      pMultisampleState = pMultisampleState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ )
-    {
-      pDepthStencilState = pDepthStencilState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ )
-    {
-      pColorBlendState = pColorBlendState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ )
-    {
-      pDynamicState = pDynamicState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setLayout( PipelineLayout layout_ )
-    {
-      layout = layout_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setRenderPass( RenderPass renderPass_ )
-    {
-      renderPass = renderPass_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setSubpass( uint32_t subpass_ )
-    {
-      subpass = subpass_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
-    {
-      basePipelineHandle = basePipelineHandle_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
-    {
-      basePipelineIndex = basePipelineIndex_;
-      return *this;
-    }
-
-    operator VkGraphicsPipelineCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(this);
-    }
-
-    operator VkGraphicsPipelineCreateInfo &()
-    {
-      return *reinterpret_cast<VkGraphicsPipelineCreateInfo*>(this);
-    }
-
-    bool operator==( GraphicsPipelineCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( stageCount == rhs.stageCount )
-          && ( pStages == rhs.pStages )
-          && ( pVertexInputState == rhs.pVertexInputState )
-          && ( pInputAssemblyState == rhs.pInputAssemblyState )
-          && ( pTessellationState == rhs.pTessellationState )
-          && ( pViewportState == rhs.pViewportState )
-          && ( pRasterizationState == rhs.pRasterizationState )
-          && ( pMultisampleState == rhs.pMultisampleState )
-          && ( pDepthStencilState == rhs.pDepthStencilState )
-          && ( pColorBlendState == rhs.pColorBlendState )
-          && ( pDynamicState == rhs.pDynamicState )
-          && ( layout == rhs.layout )
-          && ( renderPass == rhs.renderPass )
-          && ( subpass == rhs.subpass )
-          && ( basePipelineHandle == rhs.basePipelineHandle )
-          && ( basePipelineIndex == rhs.basePipelineIndex );
-    }
-
-    bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eGraphicsPipelineCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCreateFlags flags;
-    uint32_t stageCount;
-    const PipelineShaderStageCreateInfo* pStages;
-    const PipelineVertexInputStateCreateInfo* pVertexInputState;
-    const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
-    const PipelineTessellationStateCreateInfo* pTessellationState;
-    const PipelineViewportStateCreateInfo* pViewportState;
-    const PipelineRasterizationStateCreateInfo* pRasterizationState;
-    const PipelineMultisampleStateCreateInfo* pMultisampleState;
-    const PipelineDepthStencilStateCreateInfo* pDepthStencilState;
-    const PipelineColorBlendStateCreateInfo* pColorBlendState;
-    const PipelineDynamicStateCreateInfo* pDynamicState;
-    PipelineLayout layout;
-    RenderPass renderPass;
-    uint32_t subpass;
-    Pipeline basePipelineHandle;
-    int32_t basePipelineIndex;
-  };
-  static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockPropertiesEXT ), "struct and wrapper have different size!" );
 
   struct PhysicalDeviceLimits
   {
     operator VkPhysicalDeviceLimits const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceLimits*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceLimits*>( this );
     }
 
     operator VkPhysicalDeviceLimits &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceLimits*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceLimits*>( this );
     }
 
     bool operator==( PhysicalDeviceLimits const& rhs ) const
@@ -28078,16 +36512,621 @@ public:
   };
   static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" );
 
+  struct PhysicalDeviceMaintenance3Properties
+  {
+    operator VkPhysicalDeviceMaintenance3Properties const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>( this );
+    }
+
+    operator VkPhysicalDeviceMaintenance3Properties &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>( this );
+    }
+
+    bool operator==( PhysicalDeviceMaintenance3Properties const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors )
+          && ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize );
+    }
+
+    bool operator!=( PhysicalDeviceMaintenance3Properties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t maxPerSetDescriptors;
+    DeviceSize maxMemoryAllocationSize;
+  };
+  static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceMemoryProperties
+  {
+    operator VkPhysicalDeviceMemoryProperties const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>( this );
+    }
+
+    operator VkPhysicalDeviceMemoryProperties &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( this );
+    }
+
+    bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const
+    {
+      return ( memoryTypeCount == rhs.memoryTypeCount )
+          && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 )
+          && ( memoryHeapCount == rhs.memoryHeapCount )
+          && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 );
+    }
+
+    bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t memoryTypeCount;
+    MemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
+    uint32_t memoryHeapCount;
+    MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
+  };
+  static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceMemoryProperties2
+  {
+    operator VkPhysicalDeviceMemoryProperties2 const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2*>( this );
+    }
+
+    operator VkPhysicalDeviceMemoryProperties2 &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( this );
+    }
+
+    bool operator==( PhysicalDeviceMemoryProperties2 const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( memoryProperties == rhs.memoryProperties );
+    }
+
+    bool operator!=( PhysicalDeviceMemoryProperties2 const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2;
+
+  public:
+    void* pNext = nullptr;
+    PhysicalDeviceMemoryProperties memoryProperties;
+  };
+  static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceMeshShaderFeaturesNV
+  {
+    PhysicalDeviceMeshShaderFeaturesNV( Bool32 taskShader_ = 0,
+                                        Bool32 meshShader_ = 0 )
+      : taskShader( taskShader_ )
+      , meshShader( meshShader_ )
+    {}
+
+    PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) );
+    }
+
+    PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) );
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderFeaturesNV & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderFeaturesNV & setTaskShader( Bool32 taskShader_ )
+    {
+      taskShader = taskShader_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderFeaturesNV & setMeshShader( Bool32 meshShader_ )
+    {
+      meshShader = meshShader_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceMeshShaderFeaturesNV const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>( this );
+    }
+
+    operator VkPhysicalDeviceMeshShaderFeaturesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>( this );
+    }
+
+    bool operator==( PhysicalDeviceMeshShaderFeaturesNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( taskShader == rhs.taskShader )
+          && ( meshShader == rhs.meshShader );
+    }
+
+    bool operator!=( PhysicalDeviceMeshShaderFeaturesNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 taskShader;
+    Bool32 meshShader;
+  };
+  static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceMeshShaderPropertiesNV
+  {
+    PhysicalDeviceMeshShaderPropertiesNV( uint32_t maxDrawMeshTasksCount_ = 0,
+                                          uint32_t maxTaskWorkGroupInvocations_ = 0,
+                                          std::array<uint32_t,3> const& maxTaskWorkGroupSize_ = { { 0 } },
+                                          uint32_t maxTaskTotalMemorySize_ = 0,
+                                          uint32_t maxTaskOutputCount_ = 0,
+                                          uint32_t maxMeshWorkGroupInvocations_ = 0,
+                                          std::array<uint32_t,3> const& maxMeshWorkGroupSize_ = { { 0 } },
+                                          uint32_t maxMeshTotalMemorySize_ = 0,
+                                          uint32_t maxMeshOutputVertices_ = 0,
+                                          uint32_t maxMeshOutputPrimitives_ = 0,
+                                          uint32_t maxMeshMultiviewViewCount_ = 0,
+                                          uint32_t meshOutputPerVertexGranularity_ = 0,
+                                          uint32_t meshOutputPerPrimitiveGranularity_ = 0 )
+      : maxDrawMeshTasksCount( maxDrawMeshTasksCount_ )
+      , maxTaskWorkGroupInvocations( maxTaskWorkGroupInvocations_ )
+      , maxTaskTotalMemorySize( maxTaskTotalMemorySize_ )
+      , maxTaskOutputCount( maxTaskOutputCount_ )
+      , maxMeshWorkGroupInvocations( maxMeshWorkGroupInvocations_ )
+      , maxMeshTotalMemorySize( maxMeshTotalMemorySize_ )
+      , maxMeshOutputVertices( maxMeshOutputVertices_ )
+      , maxMeshOutputPrimitives( maxMeshOutputPrimitives_ )
+      , maxMeshMultiviewViewCount( maxMeshMultiviewViewCount_ )
+      , meshOutputPerVertexGranularity( meshOutputPerVertexGranularity_ )
+      , meshOutputPerPrimitiveGranularity( meshOutputPerPrimitiveGranularity_ )
+    {
+      memcpy( &maxTaskWorkGroupSize, maxTaskWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
+      memcpy( &maxMeshWorkGroupSize, maxMeshWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderPropertiesNV ) );
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderPropertiesNV ) );
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setMaxDrawMeshTasksCount( uint32_t maxDrawMeshTasksCount_ )
+    {
+      maxDrawMeshTasksCount = maxDrawMeshTasksCount_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setMaxTaskWorkGroupInvocations( uint32_t maxTaskWorkGroupInvocations_ )
+    {
+      maxTaskWorkGroupInvocations = maxTaskWorkGroupInvocations_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setMaxTaskWorkGroupSize( std::array<uint32_t,3> maxTaskWorkGroupSize_ )
+    {
+      memcpy( maxTaskWorkGroupSize, maxTaskWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setMaxTaskTotalMemorySize( uint32_t maxTaskTotalMemorySize_ )
+    {
+      maxTaskTotalMemorySize = maxTaskTotalMemorySize_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setMaxTaskOutputCount( uint32_t maxTaskOutputCount_ )
+    {
+      maxTaskOutputCount = maxTaskOutputCount_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setMaxMeshWorkGroupInvocations( uint32_t maxMeshWorkGroupInvocations_ )
+    {
+      maxMeshWorkGroupInvocations = maxMeshWorkGroupInvocations_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setMaxMeshWorkGroupSize( std::array<uint32_t,3> maxMeshWorkGroupSize_ )
+    {
+      memcpy( maxMeshWorkGroupSize, maxMeshWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setMaxMeshTotalMemorySize( uint32_t maxMeshTotalMemorySize_ )
+    {
+      maxMeshTotalMemorySize = maxMeshTotalMemorySize_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setMaxMeshOutputVertices( uint32_t maxMeshOutputVertices_ )
+    {
+      maxMeshOutputVertices = maxMeshOutputVertices_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setMaxMeshOutputPrimitives( uint32_t maxMeshOutputPrimitives_ )
+    {
+      maxMeshOutputPrimitives = maxMeshOutputPrimitives_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setMaxMeshMultiviewViewCount( uint32_t maxMeshMultiviewViewCount_ )
+    {
+      maxMeshMultiviewViewCount = maxMeshMultiviewViewCount_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setMeshOutputPerVertexGranularity( uint32_t meshOutputPerVertexGranularity_ )
+    {
+      meshOutputPerVertexGranularity = meshOutputPerVertexGranularity_;
+      return *this;
+    }
+
+    PhysicalDeviceMeshShaderPropertiesNV & setMeshOutputPerPrimitiveGranularity( uint32_t meshOutputPerPrimitiveGranularity_ )
+    {
+      meshOutputPerPrimitiveGranularity = meshOutputPerPrimitiveGranularity_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceMeshShaderPropertiesNV const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>( this );
+    }
+
+    operator VkPhysicalDeviceMeshShaderPropertiesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>( this );
+    }
+
+    bool operator==( PhysicalDeviceMeshShaderPropertiesNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount )
+          && ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations )
+          && ( memcmp( maxTaskWorkGroupSize, rhs.maxTaskWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
+          && ( maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize )
+          && ( maxTaskOutputCount == rhs.maxTaskOutputCount )
+          && ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations )
+          && ( memcmp( maxMeshWorkGroupSize, rhs.maxMeshWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
+          && ( maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize )
+          && ( maxMeshOutputVertices == rhs.maxMeshOutputVertices )
+          && ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives )
+          && ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount )
+          && ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity )
+          && ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity );
+    }
+
+    bool operator!=( PhysicalDeviceMeshShaderPropertiesNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t maxDrawMeshTasksCount;
+    uint32_t maxTaskWorkGroupInvocations;
+    uint32_t maxTaskWorkGroupSize[3];
+    uint32_t maxTaskTotalMemorySize;
+    uint32_t maxTaskOutputCount;
+    uint32_t maxMeshWorkGroupInvocations;
+    uint32_t maxMeshWorkGroupSize[3];
+    uint32_t maxMeshTotalMemorySize;
+    uint32_t maxMeshOutputVertices;
+    uint32_t maxMeshOutputPrimitives;
+    uint32_t maxMeshMultiviewViewCount;
+    uint32_t meshOutputPerVertexGranularity;
+    uint32_t meshOutputPerPrimitiveGranularity;
+  };
+  static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceMultiviewFeatures
+  {
+    PhysicalDeviceMultiviewFeatures( Bool32 multiview_ = 0,
+                                     Bool32 multiviewGeometryShader_ = 0,
+                                     Bool32 multiviewTessellationShader_ = 0 )
+      : multiview( multiview_ )
+      , multiviewGeometryShader( multiviewGeometryShader_ )
+      , multiviewTessellationShader( multiviewTessellationShader_ )
+    {}
+
+    PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeatures ) );
+    }
+
+    PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeatures ) );
+      return *this;
+    }
+
+    PhysicalDeviceMultiviewFeatures & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceMultiviewFeatures & setMultiview( Bool32 multiview_ )
+    {
+      multiview = multiview_;
+      return *this;
+    }
+
+    PhysicalDeviceMultiviewFeatures & setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ )
+    {
+      multiviewGeometryShader = multiviewGeometryShader_;
+      return *this;
+    }
+
+    PhysicalDeviceMultiviewFeatures & setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ )
+    {
+      multiviewTessellationShader = multiviewTessellationShader_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceMultiviewFeatures const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>( this );
+    }
+
+    operator VkPhysicalDeviceMultiviewFeatures &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>( this );
+    }
+
+    bool operator==( PhysicalDeviceMultiviewFeatures const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( multiview == rhs.multiview )
+          && ( multiviewGeometryShader == rhs.multiviewGeometryShader )
+          && ( multiviewTessellationShader == rhs.multiviewTessellationShader );
+    }
+
+    bool operator!=( PhysicalDeviceMultiviewFeatures const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 multiview;
+    Bool32 multiviewGeometryShader;
+    Bool32 multiviewTessellationShader;
+  };
+  static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
+  {
+    operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>( this );
+    }
+
+    operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>( this );
+    }
+
+    bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( perViewPositionAllComponents == rhs.perViewPositionAllComponents );
+    }
+
+    bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 perViewPositionAllComponents;
+  };
+  static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceMultiviewProperties
+  {
+    operator VkPhysicalDeviceMultiviewProperties const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>( this );
+    }
+
+    operator VkPhysicalDeviceMultiviewProperties &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>( this );
+    }
+
+    bool operator==( PhysicalDeviceMultiviewProperties const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( maxMultiviewViewCount == rhs.maxMultiviewViewCount )
+          && ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex );
+    }
+
+    bool operator!=( PhysicalDeviceMultiviewProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t maxMultiviewViewCount;
+    uint32_t maxMultiviewInstanceIndex;
+  };
+  static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "struct and wrapper have different size!" );
+
+  struct PhysicalDevicePCIBusInfoPropertiesEXT
+  {
+    operator VkPhysicalDevicePCIBusInfoPropertiesEXT const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>( this );
+    }
+
+    operator VkPhysicalDevicePCIBusInfoPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDevicePCIBusInfoPropertiesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( pciDomain == rhs.pciDomain )
+          && ( pciBus == rhs.pciBus )
+          && ( pciDevice == rhs.pciDevice )
+          && ( pciFunction == rhs.pciFunction );
+    }
+
+    bool operator!=( PhysicalDevicePCIBusInfoPropertiesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT;
+
+  public:
+    void* pNext = nullptr;
+    uint16_t pciDomain;
+    uint8_t pciBus;
+    uint8_t pciDevice;
+    uint8_t pciFunction;
+  };
+  static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "struct and wrapper have different size!" );
+
+  struct PhysicalDevicePointClippingProperties
+  {
+    operator VkPhysicalDevicePointClippingProperties const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>( this );
+    }
+
+    operator VkPhysicalDevicePointClippingProperties &()
+    {
+      return *reinterpret_cast<VkPhysicalDevicePointClippingProperties*>( this );
+    }
+
+    bool operator==( PhysicalDevicePointClippingProperties const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( pointClippingBehavior == rhs.pointClippingBehavior );
+    }
+
+    bool operator!=( PhysicalDevicePointClippingProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDevicePointClippingProperties;
+
+  public:
+    void* pNext = nullptr;
+    PointClippingBehavior pointClippingBehavior;
+  };
+  static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceSparseProperties
+  {
+    operator VkPhysicalDeviceSparseProperties const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceSparseProperties*>( this );
+    }
+
+    operator VkPhysicalDeviceSparseProperties &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceSparseProperties*>( this );
+    }
+
+    bool operator==( PhysicalDeviceSparseProperties const& rhs ) const
+    {
+      return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape )
+          && ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape )
+          && ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape )
+          && ( residencyAlignedMipSize == rhs.residencyAlignedMipSize )
+          && ( residencyNonResidentStrict == rhs.residencyNonResidentStrict );
+    }
+
+    bool operator!=( PhysicalDeviceSparseProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    Bool32 residencyStandard2DBlockShape;
+    Bool32 residencyStandard2DMultisampleBlockShape;
+    Bool32 residencyStandard3DBlockShape;
+    Bool32 residencyAlignedMipSize;
+    Bool32 residencyNonResidentStrict;
+  };
+  static_assert( sizeof( PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), "struct and wrapper have different size!" );
+
   struct PhysicalDeviceProperties
   {
     operator VkPhysicalDeviceProperties const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceProperties*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceProperties*>( this );
     }
 
     operator VkPhysicalDeviceProperties &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceProperties*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceProperties*>( this );
     }
 
     bool operator==( PhysicalDeviceProperties const& rhs ) const
@@ -28124,12 +37163,12 @@ public:
   {
     operator VkPhysicalDeviceProperties2 const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceProperties2*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceProperties2*>( this );
     }
 
     operator VkPhysicalDeviceProperties2 &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceProperties2*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceProperties2*>( this );
     }
 
     bool operator==( PhysicalDeviceProperties2 const& rhs ) const
@@ -28153,519 +37192,386 @@ public:
   };
   static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "struct and wrapper have different size!" );
 
-  using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
-
-  struct ImageFormatProperties2
+  struct PhysicalDeviceProtectedMemoryFeatures
   {
-    operator VkImageFormatProperties2 const&() const
+    PhysicalDeviceProtectedMemoryFeatures( Bool32 protectedMemory_ = 0 )
+      : protectedMemory( protectedMemory_ )
+    {}
+
+    PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs )
     {
-      return *reinterpret_cast<const VkImageFormatProperties2*>(this);
+      memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryFeatures ) );
     }
 
-    operator VkImageFormatProperties2 &()
+    PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs )
     {
-      return *reinterpret_cast<VkImageFormatProperties2*>(this);
+      memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryFeatures ) );
+      return *this;
     }
 
-    bool operator==( ImageFormatProperties2 const& rhs ) const
+    PhysicalDeviceProtectedMemoryFeatures & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceProtectedMemoryFeatures & setProtectedMemory( Bool32 protectedMemory_ )
+    {
+      protectedMemory = protectedMemory_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceProtectedMemoryFeatures const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>( this );
+    }
+
+    operator VkPhysicalDeviceProtectedMemoryFeatures &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>( this );
+    }
+
+    bool operator==( PhysicalDeviceProtectedMemoryFeatures const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( imageFormatProperties == rhs.imageFormatProperties );
+          && ( protectedMemory == rhs.protectedMemory );
     }
 
-    bool operator!=( ImageFormatProperties2 const& rhs ) const
+    bool operator!=( PhysicalDeviceProtectedMemoryFeatures const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eImageFormatProperties2;
+    StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures;
 
   public:
     void* pNext = nullptr;
-    ImageFormatProperties imageFormatProperties;
+    Bool32 protectedMemory;
   };
-  static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "struct and wrapper have different size!" );
 
-  using ImageFormatProperties2KHR = ImageFormatProperties2;
-
-  struct PhysicalDeviceSparseImageFormatInfo2
+  struct PhysicalDeviceProtectedMemoryProperties
   {
-    PhysicalDeviceSparseImageFormatInfo2( Format format_ = Format::eUndefined,
-                                          ImageType type_ = ImageType::e1D,
-                                          SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
-                                          ImageUsageFlags usage_ = ImageUsageFlags(),
-                                          ImageTiling tiling_ = ImageTiling::eOptimal )
-      : format( format_ )
-      , type( type_ )
-      , samples( samples_ )
-      , usage( usage_ )
-      , tiling( tiling_ )
+    PhysicalDeviceProtectedMemoryProperties( Bool32 protectedNoFault_ = 0 )
+      : protectedNoFault( protectedNoFault_ )
+    {}
+
+    PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryProperties ) );
     }
 
-    PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
+    PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs )
     {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) );
-    }
-
-    PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryProperties ) );
       return *this;
     }
-    PhysicalDeviceSparseImageFormatInfo2& setPNext( const void* pNext_ )
+
+    PhysicalDeviceProtectedMemoryProperties & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PhysicalDeviceSparseImageFormatInfo2& setFormat( Format format_ )
+    PhysicalDeviceProtectedMemoryProperties & setProtectedNoFault( Bool32 protectedNoFault_ )
     {
-      format = format_;
+      protectedNoFault = protectedNoFault_;
       return *this;
     }
 
-    PhysicalDeviceSparseImageFormatInfo2& setType( ImageType type_ )
+    operator VkPhysicalDeviceProtectedMemoryProperties const&() const
     {
-      type = type_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>( this );
     }
 
-    PhysicalDeviceSparseImageFormatInfo2& setSamples( SampleCountFlagBits samples_ )
+    operator VkPhysicalDeviceProtectedMemoryProperties &()
     {
-      samples = samples_;
-      return *this;
+      return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>( this );
     }
 
-    PhysicalDeviceSparseImageFormatInfo2& setUsage( ImageUsageFlags usage_ )
-    {
-      usage = usage_;
-      return *this;
-    }
-
-    PhysicalDeviceSparseImageFormatInfo2& setTiling( ImageTiling tiling_ )
-    {
-      tiling = tiling_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceSparseImageFormatInfo2 const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>(this);
-    }
-
-    operator VkPhysicalDeviceSparseImageFormatInfo2 &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(this);
-    }
-
-    bool operator==( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) const
+    bool operator==( PhysicalDeviceProtectedMemoryProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( format == rhs.format )
-          && ( type == rhs.type )
-          && ( samples == rhs.samples )
-          && ( usage == rhs.usage )
-          && ( tiling == rhs.tiling );
+          && ( protectedNoFault == rhs.protectedNoFault );
     }
 
-    bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) const
+    bool operator!=( PhysicalDeviceProtectedMemoryProperties const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2;
+    StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties;
 
   public:
-    const void* pNext = nullptr;
-    Format format;
-    ImageType type;
-    SampleCountFlagBits samples;
-    ImageUsageFlags usage;
-    ImageTiling tiling;
+    void* pNext = nullptr;
+    Bool32 protectedNoFault;
   };
-  static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "struct and wrapper have different size!" );
 
-  using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
-
-  struct SampleLocationsInfoEXT
+  struct PhysicalDevicePushDescriptorPropertiesKHR
   {
-    SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1,
-                            Extent2D sampleLocationGridSize_ = Extent2D(),
-                            uint32_t sampleLocationsCount_ = 0,
-                            const SampleLocationEXT* pSampleLocations_ = nullptr )
-      : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
-      , sampleLocationGridSize( sampleLocationGridSize_ )
-      , sampleLocationsCount( sampleLocationsCount_ )
-      , pSampleLocations( pSampleLocations_ )
+    PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 )
+      : maxPushDescriptors( maxPushDescriptors_ )
+    {}
+
+    PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) );
     }
 
-    SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs )
+    PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
     {
-      memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
-    }
-
-    SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
+      memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) );
       return *this;
     }
-    SampleLocationsInfoEXT& setPNext( const void* pNext_ )
+
+    PhysicalDevicePushDescriptorPropertiesKHR & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    SampleLocationsInfoEXT& setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ )
+    PhysicalDevicePushDescriptorPropertiesKHR & setMaxPushDescriptors( uint32_t maxPushDescriptors_ )
     {
-      sampleLocationsPerPixel = sampleLocationsPerPixel_;
+      maxPushDescriptors = maxPushDescriptors_;
       return *this;
     }
 
-    SampleLocationsInfoEXT& setSampleLocationGridSize( Extent2D sampleLocationGridSize_ )
+    operator VkPhysicalDevicePushDescriptorPropertiesKHR const&() const
     {
-      sampleLocationGridSize = sampleLocationGridSize_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>( this );
     }
 
-    SampleLocationsInfoEXT& setSampleLocationsCount( uint32_t sampleLocationsCount_ )
+    operator VkPhysicalDevicePushDescriptorPropertiesKHR &()
     {
-      sampleLocationsCount = sampleLocationsCount_;
-      return *this;
+      return *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>( this );
     }
 
-    SampleLocationsInfoEXT& setPSampleLocations( const SampleLocationEXT* pSampleLocations_ )
-    {
-      pSampleLocations = pSampleLocations_;
-      return *this;
-    }
-
-    operator VkSampleLocationsInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkSampleLocationsInfoEXT*>(this);
-    }
-
-    operator VkSampleLocationsInfoEXT &()
-    {
-      return *reinterpret_cast<VkSampleLocationsInfoEXT*>(this);
-    }
-
-    bool operator==( SampleLocationsInfoEXT const& rhs ) const
+    bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel )
-          && ( sampleLocationGridSize == rhs.sampleLocationGridSize )
-          && ( sampleLocationsCount == rhs.sampleLocationsCount )
-          && ( pSampleLocations == rhs.pSampleLocations );
+          && ( maxPushDescriptors == rhs.maxPushDescriptors );
     }
 
-    bool operator!=( SampleLocationsInfoEXT const& rhs ) const
+    bool operator!=( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eSampleLocationsInfoEXT;
+    StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR;
 
   public:
-    const void* pNext = nullptr;
-    SampleCountFlagBits sampleLocationsPerPixel;
-    Extent2D sampleLocationGridSize;
-    uint32_t sampleLocationsCount;
-    const SampleLocationEXT* pSampleLocations;
+    void* pNext = nullptr;
+    uint32_t maxPushDescriptors;
   };
-  static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" );
 
-  struct AttachmentSampleLocationsEXT
+  struct PhysicalDeviceRayTracingPropertiesNV
   {
-    AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = 0,
-                                  SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
-      : attachmentIndex( attachmentIndex_ )
-      , sampleLocationsInfo( sampleLocationsInfo_ )
+    PhysicalDeviceRayTracingPropertiesNV( uint32_t shaderGroupHandleSize_ = 0,
+                                          uint32_t maxRecursionDepth_ = 0,
+                                          uint32_t maxShaderGroupStride_ = 0,
+                                          uint32_t shaderGroupBaseAlignment_ = 0,
+                                          uint64_t maxGeometryCount_ = 0,
+                                          uint64_t maxInstanceCount_ = 0,
+                                          uint64_t maxTriangleCount_ = 0,
+                                          uint32_t maxDescriptorSetAccelerationStructures_ = 0 )
+      : shaderGroupHandleSize( shaderGroupHandleSize_ )
+      , maxRecursionDepth( maxRecursionDepth_ )
+      , maxShaderGroupStride( maxShaderGroupStride_ )
+      , shaderGroupBaseAlignment( shaderGroupBaseAlignment_ )
+      , maxGeometryCount( maxGeometryCount_ )
+      , maxInstanceCount( maxInstanceCount_ )
+      , maxTriangleCount( maxTriangleCount_ )
+      , maxDescriptorSetAccelerationStructures( maxDescriptorSetAccelerationStructures_ )
+    {}
+
+    PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceRayTracingPropertiesNV ) );
     }
 
-    AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs )
+    PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
-    }
-
-    AttachmentSampleLocationsEXT& operator=( VkAttachmentSampleLocationsEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
-      return *this;
-    }
-    AttachmentSampleLocationsEXT& setAttachmentIndex( uint32_t attachmentIndex_ )
-    {
-      attachmentIndex = attachmentIndex_;
+      memcpy( this, &rhs, sizeof( PhysicalDeviceRayTracingPropertiesNV ) );
       return *this;
     }
 
-    AttachmentSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
-    {
-      sampleLocationsInfo = sampleLocationsInfo_;
-      return *this;
-    }
-
-    operator VkAttachmentSampleLocationsEXT const&() const
-    {
-      return *reinterpret_cast<const VkAttachmentSampleLocationsEXT*>(this);
-    }
-
-    operator VkAttachmentSampleLocationsEXT &()
-    {
-      return *reinterpret_cast<VkAttachmentSampleLocationsEXT*>(this);
-    }
-
-    bool operator==( AttachmentSampleLocationsEXT const& rhs ) const
-    {
-      return ( attachmentIndex == rhs.attachmentIndex )
-          && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
-    }
-
-    bool operator!=( AttachmentSampleLocationsEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t attachmentIndex;
-    SampleLocationsInfoEXT sampleLocationsInfo;
-  };
-  static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" );
-
-  struct SubpassSampleLocationsEXT
-  {
-    SubpassSampleLocationsEXT( uint32_t subpassIndex_ = 0,
-                               SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
-      : subpassIndex( subpassIndex_ )
-      , sampleLocationsInfo( sampleLocationsInfo_ )
-    {
-    }
-
-    SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
-    }
-
-    SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
-      return *this;
-    }
-    SubpassSampleLocationsEXT& setSubpassIndex( uint32_t subpassIndex_ )
-    {
-      subpassIndex = subpassIndex_;
-      return *this;
-    }
-
-    SubpassSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
-    {
-      sampleLocationsInfo = sampleLocationsInfo_;
-      return *this;
-    }
-
-    operator VkSubpassSampleLocationsEXT const&() const
-    {
-      return *reinterpret_cast<const VkSubpassSampleLocationsEXT*>(this);
-    }
-
-    operator VkSubpassSampleLocationsEXT &()
-    {
-      return *reinterpret_cast<VkSubpassSampleLocationsEXT*>(this);
-    }
-
-    bool operator==( SubpassSampleLocationsEXT const& rhs ) const
-    {
-      return ( subpassIndex == rhs.subpassIndex )
-          && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
-    }
-
-    bool operator!=( SubpassSampleLocationsEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t subpassIndex;
-    SampleLocationsInfoEXT sampleLocationsInfo;
-  };
-  static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" );
-
-  struct RenderPassSampleLocationsBeginInfoEXT
-  {
-    RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0,
-                                           const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr,
-                                           uint32_t postSubpassSampleLocationsCount_ = 0,
-                                           const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
-      : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
-      , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
-      , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
-      , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
-    {
-    }
-
-    RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
-    }
-
-    RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
-      return *this;
-    }
-    RenderPassSampleLocationsBeginInfoEXT& setPNext( const void* pNext_ )
+    PhysicalDeviceRayTracingPropertiesNV & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    RenderPassSampleLocationsBeginInfoEXT& setAttachmentInitialSampleLocationsCount( uint32_t attachmentInitialSampleLocationsCount_ )
+    PhysicalDeviceRayTracingPropertiesNV & setShaderGroupHandleSize( uint32_t shaderGroupHandleSize_ )
     {
-      attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_;
+      shaderGroupHandleSize = shaderGroupHandleSize_;
       return *this;
     }
 
-    RenderPassSampleLocationsBeginInfoEXT& setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ )
+    PhysicalDeviceRayTracingPropertiesNV & setMaxRecursionDepth( uint32_t maxRecursionDepth_ )
     {
-      pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_;
+      maxRecursionDepth = maxRecursionDepth_;
       return *this;
     }
 
-    RenderPassSampleLocationsBeginInfoEXT& setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ )
+    PhysicalDeviceRayTracingPropertiesNV & setMaxShaderGroupStride( uint32_t maxShaderGroupStride_ )
     {
-      postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_;
+      maxShaderGroupStride = maxShaderGroupStride_;
       return *this;
     }
 
-    RenderPassSampleLocationsBeginInfoEXT& setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ )
+    PhysicalDeviceRayTracingPropertiesNV & setShaderGroupBaseAlignment( uint32_t shaderGroupBaseAlignment_ )
     {
-      pPostSubpassSampleLocations = pPostSubpassSampleLocations_;
+      shaderGroupBaseAlignment = shaderGroupBaseAlignment_;
       return *this;
     }
 
-    operator VkRenderPassSampleLocationsBeginInfoEXT const&() const
+    PhysicalDeviceRayTracingPropertiesNV & setMaxGeometryCount( uint64_t maxGeometryCount_ )
     {
-      return *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(this);
+      maxGeometryCount = maxGeometryCount_;
+      return *this;
     }
 
-    operator VkRenderPassSampleLocationsBeginInfoEXT &()
+    PhysicalDeviceRayTracingPropertiesNV & setMaxInstanceCount( uint64_t maxInstanceCount_ )
     {
-      return *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(this);
+      maxInstanceCount = maxInstanceCount_;
+      return *this;
     }
 
-    bool operator==( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const
+    PhysicalDeviceRayTracingPropertiesNV & setMaxTriangleCount( uint64_t maxTriangleCount_ )
+    {
+      maxTriangleCount = maxTriangleCount_;
+      return *this;
+    }
+
+    PhysicalDeviceRayTracingPropertiesNV & setMaxDescriptorSetAccelerationStructures( uint32_t maxDescriptorSetAccelerationStructures_ )
+    {
+      maxDescriptorSetAccelerationStructures = maxDescriptorSetAccelerationStructures_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceRayTracingPropertiesNV const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>( this );
+    }
+
+    operator VkPhysicalDeviceRayTracingPropertiesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>( this );
+    }
+
+    bool operator==( PhysicalDeviceRayTracingPropertiesNV const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount )
-          && ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations )
-          && ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount )
-          && ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations );
+          && ( shaderGroupHandleSize == rhs.shaderGroupHandleSize )
+          && ( maxRecursionDepth == rhs.maxRecursionDepth )
+          && ( maxShaderGroupStride == rhs.maxShaderGroupStride )
+          && ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment )
+          && ( maxGeometryCount == rhs.maxGeometryCount )
+          && ( maxInstanceCount == rhs.maxInstanceCount )
+          && ( maxTriangleCount == rhs.maxTriangleCount )
+          && ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures );
     }
 
-    bool operator!=( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const
+    bool operator!=( PhysicalDeviceRayTracingPropertiesNV const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
+    StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV;
 
   public:
-    const void* pNext = nullptr;
-    uint32_t attachmentInitialSampleLocationsCount;
-    const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations;
-    uint32_t postSubpassSampleLocationsCount;
-    const SubpassSampleLocationsEXT* pPostSubpassSampleLocations;
+    void* pNext = nullptr;
+    uint32_t shaderGroupHandleSize;
+    uint32_t maxRecursionDepth;
+    uint32_t maxShaderGroupStride;
+    uint32_t shaderGroupBaseAlignment;
+    uint64_t maxGeometryCount;
+    uint64_t maxInstanceCount;
+    uint64_t maxTriangleCount;
+    uint32_t maxDescriptorSetAccelerationStructures;
   };
-  static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "struct and wrapper have different size!" );
 
-  struct PipelineSampleLocationsStateCreateInfoEXT
+  struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV
   {
-    PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = 0,
-                                               SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
-      : sampleLocationsEnable( sampleLocationsEnable_ )
-      , sampleLocationsInfo( sampleLocationsInfo_ )
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV( Bool32 representativeFragmentTest_ = 0 )
+      : representativeFragmentTest( representativeFragmentTest_ )
+    {}
+
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) );
     }
 
-    PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
-    }
-
-    PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) );
       return *this;
     }
-    PipelineSampleLocationsStateCreateInfoEXT& setPNext( const void* pNext_ )
+
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setPNext( void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsEnable( Bool32 sampleLocationsEnable_ )
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setRepresentativeFragmentTest( Bool32 representativeFragmentTest_ )
     {
-      sampleLocationsEnable = sampleLocationsEnable_;
+      representativeFragmentTest = representativeFragmentTest_;
       return *this;
     }
 
-    PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+    operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const&() const
     {
-      sampleLocationsInfo = sampleLocationsInfo_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>( this );
     }
 
-    operator VkPipelineSampleLocationsStateCreateInfoEXT const&() const
+    operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV &()
     {
-      return *reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>( this );
     }
 
-    operator VkPipelineSampleLocationsStateCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(this);
-    }
-
-    bool operator==( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const
+    bool operator==( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( sampleLocationsEnable == rhs.sampleLocationsEnable )
-          && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+          && ( representativeFragmentTest == rhs.representativeFragmentTest );
     }
 
-    bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const
+    bool operator!=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
+    StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV;
 
   public:
-    const void* pNext = nullptr;
-    Bool32 sampleLocationsEnable;
-    SampleLocationsInfoEXT sampleLocationsInfo;
+    void* pNext = nullptr;
+    Bool32 representativeFragmentTest;
   };
-  static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "struct and wrapper have different size!" );
 
   struct PhysicalDeviceSampleLocationsPropertiesEXT
   {
     operator VkPhysicalDeviceSampleLocationsPropertiesEXT const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>( this );
     }
 
     operator VkPhysicalDeviceSampleLocationsPropertiesEXT &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>( this );
     }
 
     bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const
@@ -28697,2106 +37603,627 @@ public:
   };
   static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "struct and wrapper have different size!" );
 
-  enum class AttachmentDescriptionFlagBits
+  struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
   {
-    eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
-  };
-
-  using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits, VkAttachmentDescriptionFlags>;
-
-  VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
-  {
-    return AttachmentDescriptionFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits )
-  {
-    return ~( AttachmentDescriptionFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<AttachmentDescriptionFlagBits>
-  {
-    enum
+    operator VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const&() const
     {
-      allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias)
-    };
-  };
+      return *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>( this );
+    }
 
-  struct AttachmentDescription
+    operator VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats )
+          && ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping );
+    }
+
+    bool operator!=( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 filterMinmaxSingleComponentFormats;
+    Bool32 filterMinmaxImageComponentMapping;
+  };
+  static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceSamplerYcbcrConversionFeatures
   {
-    AttachmentDescription( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(),
-                           Format format_ = Format::eUndefined,
-                           SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
-                           AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad,
-                           AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore,
-                           AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad,
-                           AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore,
-                           ImageLayout initialLayout_ = ImageLayout::eUndefined,
-                           ImageLayout finalLayout_ = ImageLayout::eUndefined )
-      : flags( flags_ )
-      , format( format_ )
+    PhysicalDeviceSamplerYcbcrConversionFeatures( Bool32 samplerYcbcrConversion_ = 0 )
+      : samplerYcbcrConversion( samplerYcbcrConversion_ )
+    {}
+
+    PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) );
+    }
+
+    PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) );
+      return *this;
+    }
+
+    PhysicalDeviceSamplerYcbcrConversionFeatures & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceSamplerYcbcrConversionFeatures & setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ )
+    {
+      samplerYcbcrConversion = samplerYcbcrConversion_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>( this );
+    }
+
+    operator VkPhysicalDeviceSamplerYcbcrConversionFeatures &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>( this );
+    }
+
+    bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( samplerYcbcrConversion == rhs.samplerYcbcrConversion );
+    }
+
+    bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeatures const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 samplerYcbcrConversion;
+  };
+  static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceScalarBlockLayoutFeaturesEXT
+  {
+    PhysicalDeviceScalarBlockLayoutFeaturesEXT( Bool32 scalarBlockLayout_ = 0 )
+      : scalarBlockLayout( scalarBlockLayout_ )
+    {}
+
+    PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) );
+    }
+
+    PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) );
+      return *this;
+    }
+
+    PhysicalDeviceScalarBlockLayoutFeaturesEXT & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceScalarBlockLayoutFeaturesEXT & setScalarBlockLayout( Bool32 scalarBlockLayout_ )
+    {
+      scalarBlockLayout = scalarBlockLayout_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeaturesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceScalarBlockLayoutFeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDeviceScalarBlockLayoutFeaturesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( scalarBlockLayout == rhs.scalarBlockLayout );
+    }
+
+    bool operator!=( PhysicalDeviceScalarBlockLayoutFeaturesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 scalarBlockLayout;
+  };
+  static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceShaderAtomicInt64FeaturesKHR
+  {
+    PhysicalDeviceShaderAtomicInt64FeaturesKHR( Bool32 shaderBufferInt64Atomics_ = 0,
+                                                Bool32 shaderSharedInt64Atomics_ = 0 )
+      : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ )
+      , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ )
+    {}
+
+    PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) );
+    }
+
+    PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) );
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicInt64FeaturesKHR & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ )
+    {
+      shaderBufferInt64Atomics = shaderBufferInt64Atomics_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ )
+    {
+      shaderSharedInt64Atomics = shaderSharedInt64Atomics_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>( this );
+    }
+
+    operator VkPhysicalDeviceShaderAtomicInt64FeaturesKHR &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>( this );
+    }
+
+    bool operator==( PhysicalDeviceShaderAtomicInt64FeaturesKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics )
+          && ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics );
+    }
+
+    bool operator!=( PhysicalDeviceShaderAtomicInt64FeaturesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 shaderBufferInt64Atomics;
+    Bool32 shaderSharedInt64Atomics;
+  };
+  static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceShaderCorePropertiesAMD
+  {
+    operator VkPhysicalDeviceShaderCorePropertiesAMD const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>( this );
+    }
+
+    operator VkPhysicalDeviceShaderCorePropertiesAMD &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>( this );
+    }
+
+    bool operator==( PhysicalDeviceShaderCorePropertiesAMD const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( shaderEngineCount == rhs.shaderEngineCount )
+          && ( shaderArraysPerEngineCount == rhs.shaderArraysPerEngineCount )
+          && ( computeUnitsPerShaderArray == rhs.computeUnitsPerShaderArray )
+          && ( simdPerComputeUnit == rhs.simdPerComputeUnit )
+          && ( wavefrontsPerSimd == rhs.wavefrontsPerSimd )
+          && ( wavefrontSize == rhs.wavefrontSize )
+          && ( sgprsPerSimd == rhs.sgprsPerSimd )
+          && ( minSgprAllocation == rhs.minSgprAllocation )
+          && ( maxSgprAllocation == rhs.maxSgprAllocation )
+          && ( sgprAllocationGranularity == rhs.sgprAllocationGranularity )
+          && ( vgprsPerSimd == rhs.vgprsPerSimd )
+          && ( minVgprAllocation == rhs.minVgprAllocation )
+          && ( maxVgprAllocation == rhs.maxVgprAllocation )
+          && ( vgprAllocationGranularity == rhs.vgprAllocationGranularity );
+    }
+
+    bool operator!=( PhysicalDeviceShaderCorePropertiesAMD const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t shaderEngineCount;
+    uint32_t shaderArraysPerEngineCount;
+    uint32_t computeUnitsPerShaderArray;
+    uint32_t simdPerComputeUnit;
+    uint32_t wavefrontsPerSimd;
+    uint32_t wavefrontSize;
+    uint32_t sgprsPerSimd;
+    uint32_t minSgprAllocation;
+    uint32_t maxSgprAllocation;
+    uint32_t sgprAllocationGranularity;
+    uint32_t vgprsPerSimd;
+    uint32_t minVgprAllocation;
+    uint32_t maxVgprAllocation;
+    uint32_t vgprAllocationGranularity;
+  };
+  static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceShaderDrawParameterFeatures
+  {
+    PhysicalDeviceShaderDrawParameterFeatures( Bool32 shaderDrawParameters_ = 0 )
+      : shaderDrawParameters( shaderDrawParameters_ )
+    {}
+
+    PhysicalDeviceShaderDrawParameterFeatures( VkPhysicalDeviceShaderDrawParameterFeatures const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParameterFeatures ) );
+    }
+
+    PhysicalDeviceShaderDrawParameterFeatures& operator=( VkPhysicalDeviceShaderDrawParameterFeatures const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParameterFeatures ) );
+      return *this;
+    }
+
+    PhysicalDeviceShaderDrawParameterFeatures & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderDrawParameterFeatures & setShaderDrawParameters( Bool32 shaderDrawParameters_ )
+    {
+      shaderDrawParameters = shaderDrawParameters_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceShaderDrawParameterFeatures const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShaderDrawParameterFeatures*>( this );
+    }
+
+    operator VkPhysicalDeviceShaderDrawParameterFeatures &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures*>( this );
+    }
+
+    bool operator==( PhysicalDeviceShaderDrawParameterFeatures const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( shaderDrawParameters == rhs.shaderDrawParameters );
+    }
+
+    bool operator!=( PhysicalDeviceShaderDrawParameterFeatures const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceShaderDrawParameterFeatures;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 shaderDrawParameters;
+  };
+  static_assert( sizeof( PhysicalDeviceShaderDrawParameterFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParameterFeatures ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceShaderImageFootprintFeaturesNV
+  {
+    PhysicalDeviceShaderImageFootprintFeaturesNV( Bool32 imageFootprint_ = 0 )
+      : imageFootprint( imageFootprint_ )
+    {}
+
+    PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) );
+    }
+
+    PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) );
+      return *this;
+    }
+
+    PhysicalDeviceShaderImageFootprintFeaturesNV & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderImageFootprintFeaturesNV & setImageFootprint( Bool32 imageFootprint_ )
+    {
+      imageFootprint = imageFootprint_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>( this );
+    }
+
+    operator VkPhysicalDeviceShaderImageFootprintFeaturesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>( this );
+    }
+
+    bool operator==( PhysicalDeviceShaderImageFootprintFeaturesNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( imageFootprint == rhs.imageFootprint );
+    }
+
+    bool operator!=( PhysicalDeviceShaderImageFootprintFeaturesNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 imageFootprint;
+  };
+  static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceShadingRateImageFeaturesNV
+  {
+    PhysicalDeviceShadingRateImageFeaturesNV( Bool32 shadingRateImage_ = 0,
+                                              Bool32 shadingRateCoarseSampleOrder_ = 0 )
+      : shadingRateImage( shadingRateImage_ )
+      , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ )
+    {}
+
+    PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) );
+    }
+
+    PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) );
+      return *this;
+    }
+
+    PhysicalDeviceShadingRateImageFeaturesNV & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateImage( Bool32 shadingRateImage_ )
+    {
+      shadingRateImage = shadingRateImage_;
+      return *this;
+    }
+
+    PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateCoarseSampleOrder( Bool32 shadingRateCoarseSampleOrder_ )
+    {
+      shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceShadingRateImageFeaturesNV const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>( this );
+    }
+
+    operator VkPhysicalDeviceShadingRateImageFeaturesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>( this );
+    }
+
+    bool operator==( PhysicalDeviceShadingRateImageFeaturesNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( shadingRateImage == rhs.shadingRateImage )
+          && ( shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder );
+    }
+
+    bool operator!=( PhysicalDeviceShadingRateImageFeaturesNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 shadingRateImage;
+    Bool32 shadingRateCoarseSampleOrder;
+  };
+  static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceShadingRateImagePropertiesNV
+  {
+    operator VkPhysicalDeviceShadingRateImagePropertiesNV const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>( this );
+    }
+
+    operator VkPhysicalDeviceShadingRateImagePropertiesNV &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>( this );
+    }
+
+    bool operator==( PhysicalDeviceShadingRateImagePropertiesNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( shadingRateTexelSize == rhs.shadingRateTexelSize )
+          && ( shadingRatePaletteSize == rhs.shadingRatePaletteSize )
+          && ( shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples );
+    }
+
+    bool operator!=( PhysicalDeviceShadingRateImagePropertiesNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV;
+
+  public:
+    void* pNext = nullptr;
+    Extent2D shadingRateTexelSize;
+    uint32_t shadingRatePaletteSize;
+    uint32_t shadingRateMaxCoarseSamples;
+  };
+  static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceSparseImageFormatInfo2
+  {
+    PhysicalDeviceSparseImageFormatInfo2( Format format_ = Format::eUndefined,
+                                          ImageType type_ = ImageType::e1D,
+                                          SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
+                                          ImageUsageFlags usage_ = ImageUsageFlags(),
+                                          ImageTiling tiling_ = ImageTiling::eOptimal )
+      : format( format_ )
+      , type( type_ )
       , samples( samples_ )
-      , loadOp( loadOp_ )
-      , storeOp( storeOp_ )
-      , stencilLoadOp( stencilLoadOp_ )
-      , stencilStoreOp( stencilStoreOp_ )
-      , initialLayout( initialLayout_ )
-      , finalLayout( finalLayout_ )
+      , usage( usage_ )
+      , tiling( tiling_ )
+    {}
+
+    PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
     {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) );
     }
 
-    AttachmentDescription( VkAttachmentDescription const & rhs )
+    PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
     {
-      memcpy( this, &rhs, sizeof( AttachmentDescription ) );
-    }
-
-    AttachmentDescription& operator=( VkAttachmentDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentDescription ) );
-      return *this;
-    }
-    AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ )
-    {
-      flags = flags_;
+      memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) );
       return *this;
     }
 
-    AttachmentDescription& setFormat( Format format_ )
+    PhysicalDeviceSparseImageFormatInfo2 & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceSparseImageFormatInfo2 & setFormat( Format format_ )
     {
       format = format_;
       return *this;
     }
 
-    AttachmentDescription& setSamples( SampleCountFlagBits samples_ )
+    PhysicalDeviceSparseImageFormatInfo2 & setType( ImageType type_ )
+    {
+      type = type_;
+      return *this;
+    }
+
+    PhysicalDeviceSparseImageFormatInfo2 & setSamples( SampleCountFlagBits samples_ )
     {
       samples = samples_;
       return *this;
     }
 
-    AttachmentDescription& setLoadOp( AttachmentLoadOp loadOp_ )
+    PhysicalDeviceSparseImageFormatInfo2 & setUsage( ImageUsageFlags usage_ )
     {
-      loadOp = loadOp_;
+      usage = usage_;
       return *this;
     }
 
-    AttachmentDescription& setStoreOp( AttachmentStoreOp storeOp_ )
+    PhysicalDeviceSparseImageFormatInfo2 & setTiling( ImageTiling tiling_ )
     {
-      storeOp = storeOp_;
+      tiling = tiling_;
       return *this;
     }
 
-    AttachmentDescription& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
+    operator VkPhysicalDeviceSparseImageFormatInfo2 const&() const
     {
-      stencilLoadOp = stencilLoadOp_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( this );
     }
 
-    AttachmentDescription& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
+    operator VkPhysicalDeviceSparseImageFormatInfo2 &()
     {
-      stencilStoreOp = stencilStoreOp_;
-      return *this;
+      return *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>( this );
     }
 
-    AttachmentDescription& setInitialLayout( ImageLayout initialLayout_ )
+    bool operator==( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) const
     {
-      initialLayout = initialLayout_;
-      return *this;
-    }
-
-    AttachmentDescription& setFinalLayout( ImageLayout finalLayout_ )
-    {
-      finalLayout = finalLayout_;
-      return *this;
-    }
-
-    operator VkAttachmentDescription const&() const
-    {
-      return *reinterpret_cast<const VkAttachmentDescription*>(this);
-    }
-
-    operator VkAttachmentDescription &()
-    {
-      return *reinterpret_cast<VkAttachmentDescription*>(this);
-    }
-
-    bool operator==( AttachmentDescription const& rhs ) const
-    {
-      return ( flags == rhs.flags )
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
           && ( format == rhs.format )
+          && ( type == rhs.type )
           && ( samples == rhs.samples )
-          && ( loadOp == rhs.loadOp )
-          && ( storeOp == rhs.storeOp )
-          && ( stencilLoadOp == rhs.stencilLoadOp )
-          && ( stencilStoreOp == rhs.stencilStoreOp )
-          && ( initialLayout == rhs.initialLayout )
-          && ( finalLayout == rhs.finalLayout );
+          && ( usage == rhs.usage )
+          && ( tiling == rhs.tiling );
     }
 
-    bool operator!=( AttachmentDescription const& rhs ) const
+    bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const& rhs ) const
     {
       return !operator==( rhs );
     }
 
-    AttachmentDescriptionFlags flags;
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2;
+
+  public:
+    const void* pNext = nullptr;
     Format format;
+    ImageType type;
     SampleCountFlagBits samples;
-    AttachmentLoadOp loadOp;
-    AttachmentStoreOp storeOp;
-    AttachmentLoadOp stencilLoadOp;
-    AttachmentStoreOp stencilStoreOp;
-    ImageLayout initialLayout;
-    ImageLayout finalLayout;
-  };
-  static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" );
-
-  struct AttachmentDescription2KHR
-  {
-    AttachmentDescription2KHR( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(),
-                               Format format_ = Format::eUndefined,
-                               SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
-                               AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad,
-                               AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore,
-                               AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad,
-                               AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore,
-                               ImageLayout initialLayout_ = ImageLayout::eUndefined,
-                               ImageLayout finalLayout_ = ImageLayout::eUndefined )
-      : flags( flags_ )
-      , format( format_ )
-      , samples( samples_ )
-      , loadOp( loadOp_ )
-      , storeOp( storeOp_ )
-      , stencilLoadOp( stencilLoadOp_ )
-      , stencilStoreOp( stencilStoreOp_ )
-      , initialLayout( initialLayout_ )
-      , finalLayout( finalLayout_ )
-    {
-    }
-
-    AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) );
-    }
-
-    AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) );
-      return *this;
-    }
-    AttachmentDescription2KHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    AttachmentDescription2KHR& setFlags( AttachmentDescriptionFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    AttachmentDescription2KHR& setFormat( Format format_ )
-    {
-      format = format_;
-      return *this;
-    }
-
-    AttachmentDescription2KHR& setSamples( SampleCountFlagBits samples_ )
-    {
-      samples = samples_;
-      return *this;
-    }
-
-    AttachmentDescription2KHR& setLoadOp( AttachmentLoadOp loadOp_ )
-    {
-      loadOp = loadOp_;
-      return *this;
-    }
-
-    AttachmentDescription2KHR& setStoreOp( AttachmentStoreOp storeOp_ )
-    {
-      storeOp = storeOp_;
-      return *this;
-    }
-
-    AttachmentDescription2KHR& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
-    {
-      stencilLoadOp = stencilLoadOp_;
-      return *this;
-    }
-
-    AttachmentDescription2KHR& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
-    {
-      stencilStoreOp = stencilStoreOp_;
-      return *this;
-    }
-
-    AttachmentDescription2KHR& setInitialLayout( ImageLayout initialLayout_ )
-    {
-      initialLayout = initialLayout_;
-      return *this;
-    }
-
-    AttachmentDescription2KHR& setFinalLayout( ImageLayout finalLayout_ )
-    {
-      finalLayout = finalLayout_;
-      return *this;
-    }
-
-    operator VkAttachmentDescription2KHR const&() const
-    {
-      return *reinterpret_cast<const VkAttachmentDescription2KHR*>(this);
-    }
-
-    operator VkAttachmentDescription2KHR &()
-    {
-      return *reinterpret_cast<VkAttachmentDescription2KHR*>(this);
-    }
-
-    bool operator==( AttachmentDescription2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( format == rhs.format )
-          && ( samples == rhs.samples )
-          && ( loadOp == rhs.loadOp )
-          && ( storeOp == rhs.storeOp )
-          && ( stencilLoadOp == rhs.stencilLoadOp )
-          && ( stencilStoreOp == rhs.stencilStoreOp )
-          && ( initialLayout == rhs.initialLayout )
-          && ( finalLayout == rhs.finalLayout );
-    }
-
-    bool operator!=( AttachmentDescription2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eAttachmentDescription2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    AttachmentDescriptionFlags flags;
-    Format format;
-    SampleCountFlagBits samples;
-    AttachmentLoadOp loadOp;
-    AttachmentStoreOp storeOp;
-    AttachmentLoadOp stencilLoadOp;
-    AttachmentStoreOp stencilStoreOp;
-    ImageLayout initialLayout;
-    ImageLayout finalLayout;
-  };
-  static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "struct and wrapper have different size!" );
-
-  enum class StencilFaceFlagBits
-  {
-    eFront = VK_STENCIL_FACE_FRONT_BIT,
-    eBack = VK_STENCIL_FACE_BACK_BIT,
-    eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK
-  };
-
-  using StencilFaceFlags = Flags<StencilFaceFlagBits, VkStencilFaceFlags>;
-
-  VULKAN_HPP_INLINE StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
-  {
-    return StencilFaceFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE StencilFaceFlags operator~( StencilFaceFlagBits bits )
-  {
-    return ~( StencilFaceFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<StencilFaceFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack)
-    };
-  };
-
-  enum class DescriptorPoolCreateFlagBits
-  {
-    eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
-    eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT
-  };
-
-  using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits, VkDescriptorPoolCreateFlags>;
-
-  VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
-  {
-    return DescriptorPoolCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits )
-  {
-    return ~( DescriptorPoolCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<DescriptorPoolCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) | VkFlags(DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT)
-    };
-  };
-
-  struct DescriptorPoolCreateInfo
-  {
-    DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(),
-                              uint32_t maxSets_ = 0,
-                              uint32_t poolSizeCount_ = 0,
-                              const DescriptorPoolSize* pPoolSizes_ = nullptr )
-      : flags( flags_ )
-      , maxSets( maxSets_ )
-      , poolSizeCount( poolSizeCount_ )
-      , pPoolSizes( pPoolSizes_ )
-    {
-    }
-
-    DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
-    }
-
-    DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
-      return *this;
-    }
-    DescriptorPoolCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DescriptorPoolCreateInfo& setFlags( DescriptorPoolCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DescriptorPoolCreateInfo& setMaxSets( uint32_t maxSets_ )
-    {
-      maxSets = maxSets_;
-      return *this;
-    }
-
-    DescriptorPoolCreateInfo& setPoolSizeCount( uint32_t poolSizeCount_ )
-    {
-      poolSizeCount = poolSizeCount_;
-      return *this;
-    }
-
-    DescriptorPoolCreateInfo& setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ )
-    {
-      pPoolSizes = pPoolSizes_;
-      return *this;
-    }
-
-    operator VkDescriptorPoolCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>(this);
-    }
-
-    operator VkDescriptorPoolCreateInfo &()
-    {
-      return *reinterpret_cast<VkDescriptorPoolCreateInfo*>(this);
-    }
-
-    bool operator==( DescriptorPoolCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( maxSets == rhs.maxSets )
-          && ( poolSizeCount == rhs.poolSizeCount )
-          && ( pPoolSizes == rhs.pPoolSizes );
-    }
-
-    bool operator!=( DescriptorPoolCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDescriptorPoolCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorPoolCreateFlags flags;
-    uint32_t maxSets;
-    uint32_t poolSizeCount;
-    const DescriptorPoolSize* pPoolSizes;
-  };
-  static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class DependencyFlagBits
-  {
-    eByRegion = VK_DEPENDENCY_BY_REGION_BIT,
-    eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT,
-    eDeviceGroupKHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,
-    eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT,
-    eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT
-  };
-
-  using DependencyFlags = Flags<DependencyFlagBits, VkDependencyFlags>;
-
-  VULKAN_HPP_INLINE DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 )
-  {
-    return DependencyFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DependencyFlags operator~( DependencyFlagBits bits )
-  {
-    return ~( DependencyFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<DependencyFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(DependencyFlagBits::eByRegion) | VkFlags(DependencyFlagBits::eDeviceGroup) | VkFlags(DependencyFlagBits::eViewLocal)
-    };
-  };
-
-  struct SubpassDependency
-  {
-    SubpassDependency( uint32_t srcSubpass_ = 0,
-                       uint32_t dstSubpass_ = 0,
-                       PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
-                       PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
-                       AccessFlags srcAccessMask_ = AccessFlags(),
-                       AccessFlags dstAccessMask_ = AccessFlags(),
-                       DependencyFlags dependencyFlags_ = DependencyFlags() )
-      : srcSubpass( srcSubpass_ )
-      , dstSubpass( dstSubpass_ )
-      , srcStageMask( srcStageMask_ )
-      , dstStageMask( dstStageMask_ )
-      , srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
-      , dependencyFlags( dependencyFlags_ )
-    {
-    }
-
-    SubpassDependency( VkSubpassDependency const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassDependency ) );
-    }
-
-    SubpassDependency& operator=( VkSubpassDependency const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassDependency ) );
-      return *this;
-    }
-    SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ )
-    {
-      srcSubpass = srcSubpass_;
-      return *this;
-    }
-
-    SubpassDependency& setDstSubpass( uint32_t dstSubpass_ )
-    {
-      dstSubpass = dstSubpass_;
-      return *this;
-    }
-
-    SubpassDependency& setSrcStageMask( PipelineStageFlags srcStageMask_ )
-    {
-      srcStageMask = srcStageMask_;
-      return *this;
-    }
-
-    SubpassDependency& setDstStageMask( PipelineStageFlags dstStageMask_ )
-    {
-      dstStageMask = dstStageMask_;
-      return *this;
-    }
-
-    SubpassDependency& setSrcAccessMask( AccessFlags srcAccessMask_ )
-    {
-      srcAccessMask = srcAccessMask_;
-      return *this;
-    }
-
-    SubpassDependency& setDstAccessMask( AccessFlags dstAccessMask_ )
-    {
-      dstAccessMask = dstAccessMask_;
-      return *this;
-    }
-
-    SubpassDependency& setDependencyFlags( DependencyFlags dependencyFlags_ )
-    {
-      dependencyFlags = dependencyFlags_;
-      return *this;
-    }
-
-    operator VkSubpassDependency const&() const
-    {
-      return *reinterpret_cast<const VkSubpassDependency*>(this);
-    }
-
-    operator VkSubpassDependency &()
-    {
-      return *reinterpret_cast<VkSubpassDependency*>(this);
-    }
-
-    bool operator==( SubpassDependency const& rhs ) const
-    {
-      return ( srcSubpass == rhs.srcSubpass )
-          && ( dstSubpass == rhs.dstSubpass )
-          && ( srcStageMask == rhs.srcStageMask )
-          && ( dstStageMask == rhs.dstStageMask )
-          && ( srcAccessMask == rhs.srcAccessMask )
-          && ( dstAccessMask == rhs.dstAccessMask )
-          && ( dependencyFlags == rhs.dependencyFlags );
-    }
-
-    bool operator!=( SubpassDependency const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t srcSubpass;
-    uint32_t dstSubpass;
-    PipelineStageFlags srcStageMask;
-    PipelineStageFlags dstStageMask;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
-    DependencyFlags dependencyFlags;
-  };
-  static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" );
-
-  struct SubpassDependency2KHR
-  {
-    SubpassDependency2KHR( uint32_t srcSubpass_ = 0,
-                           uint32_t dstSubpass_ = 0,
-                           PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
-                           PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
-                           AccessFlags srcAccessMask_ = AccessFlags(),
-                           AccessFlags dstAccessMask_ = AccessFlags(),
-                           DependencyFlags dependencyFlags_ = DependencyFlags(),
-                           int32_t viewOffset_ = 0 )
-      : srcSubpass( srcSubpass_ )
-      , dstSubpass( dstSubpass_ )
-      , srcStageMask( srcStageMask_ )
-      , dstStageMask( dstStageMask_ )
-      , srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
-      , dependencyFlags( dependencyFlags_ )
-      , viewOffset( viewOffset_ )
-    {
-    }
-
-    SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) );
-    }
-
-    SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) );
-      return *this;
-    }
-    SubpassDependency2KHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SubpassDependency2KHR& setSrcSubpass( uint32_t srcSubpass_ )
-    {
-      srcSubpass = srcSubpass_;
-      return *this;
-    }
-
-    SubpassDependency2KHR& setDstSubpass( uint32_t dstSubpass_ )
-    {
-      dstSubpass = dstSubpass_;
-      return *this;
-    }
-
-    SubpassDependency2KHR& setSrcStageMask( PipelineStageFlags srcStageMask_ )
-    {
-      srcStageMask = srcStageMask_;
-      return *this;
-    }
-
-    SubpassDependency2KHR& setDstStageMask( PipelineStageFlags dstStageMask_ )
-    {
-      dstStageMask = dstStageMask_;
-      return *this;
-    }
-
-    SubpassDependency2KHR& setSrcAccessMask( AccessFlags srcAccessMask_ )
-    {
-      srcAccessMask = srcAccessMask_;
-      return *this;
-    }
-
-    SubpassDependency2KHR& setDstAccessMask( AccessFlags dstAccessMask_ )
-    {
-      dstAccessMask = dstAccessMask_;
-      return *this;
-    }
-
-    SubpassDependency2KHR& setDependencyFlags( DependencyFlags dependencyFlags_ )
-    {
-      dependencyFlags = dependencyFlags_;
-      return *this;
-    }
-
-    SubpassDependency2KHR& setViewOffset( int32_t viewOffset_ )
-    {
-      viewOffset = viewOffset_;
-      return *this;
-    }
-
-    operator VkSubpassDependency2KHR const&() const
-    {
-      return *reinterpret_cast<const VkSubpassDependency2KHR*>(this);
-    }
-
-    operator VkSubpassDependency2KHR &()
-    {
-      return *reinterpret_cast<VkSubpassDependency2KHR*>(this);
-    }
-
-    bool operator==( SubpassDependency2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( srcSubpass == rhs.srcSubpass )
-          && ( dstSubpass == rhs.dstSubpass )
-          && ( srcStageMask == rhs.srcStageMask )
-          && ( dstStageMask == rhs.dstStageMask )
-          && ( srcAccessMask == rhs.srcAccessMask )
-          && ( dstAccessMask == rhs.dstAccessMask )
-          && ( dependencyFlags == rhs.dependencyFlags )
-          && ( viewOffset == rhs.viewOffset );
-    }
-
-    bool operator!=( SubpassDependency2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSubpassDependency2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t srcSubpass;
-    uint32_t dstSubpass;
-    PipelineStageFlags srcStageMask;
-    PipelineStageFlags dstStageMask;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
-    DependencyFlags dependencyFlags;
-    int32_t viewOffset;
-  };
-  static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "struct and wrapper have different size!" );
-
-  enum class PresentModeKHR
-  {
-    eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR,
-    eMailbox = VK_PRESENT_MODE_MAILBOX_KHR,
-    eFifo = VK_PRESENT_MODE_FIFO_KHR,
-    eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
-    eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR,
-    eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR
-  };
-
-  enum class ColorSpaceKHR
-  {
-    eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
-    eVkColorspaceSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
-    eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT,
-    eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT,
-    eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT,
-    eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT,
-    eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT,
-    eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT,
-    eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT,
-    eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT,
-    eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT,
-    eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT,
-    eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT,
-    eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT,
-    ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT,
-    eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT
-  };
-
-  struct SurfaceFormatKHR
-  {
-    operator VkSurfaceFormatKHR const&() const
-    {
-      return *reinterpret_cast<const VkSurfaceFormatKHR*>(this);
-    }
-
-    operator VkSurfaceFormatKHR &()
-    {
-      return *reinterpret_cast<VkSurfaceFormatKHR*>(this);
-    }
-
-    bool operator==( SurfaceFormatKHR const& rhs ) const
-    {
-      return ( format == rhs.format )
-          && ( colorSpace == rhs.colorSpace );
-    }
-
-    bool operator!=( SurfaceFormatKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Format format;
-    ColorSpaceKHR colorSpace;
-  };
-  static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" );
-
-  struct SurfaceFormat2KHR
-  {
-    operator VkSurfaceFormat2KHR const&() const
-    {
-      return *reinterpret_cast<const VkSurfaceFormat2KHR*>(this);
-    }
-
-    operator VkSurfaceFormat2KHR &()
-    {
-      return *reinterpret_cast<VkSurfaceFormat2KHR*>(this);
-    }
-
-    bool operator==( SurfaceFormat2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( surfaceFormat == rhs.surfaceFormat );
-    }
-
-    bool operator!=( SurfaceFormat2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSurfaceFormat2KHR;
-
-  public:
-    void* pNext = nullptr;
-    SurfaceFormatKHR surfaceFormat;
-  };
-  static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" );
-
-  enum class DisplayPlaneAlphaFlagBitsKHR
-  {
-    eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
-    eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
-    ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
-    ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR
-  };
-
-  using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR, VkDisplayPlaneAlphaFlagsKHR>;
-
-  VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
-  {
-    return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits )
-  {
-    return ~( DisplayPlaneAlphaFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied)
-    };
-  };
-
-  struct DisplayPlaneCapabilitiesKHR
-  {
-    operator VkDisplayPlaneCapabilitiesKHR const&() const
-    {
-      return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>(this);
-    }
-
-    operator VkDisplayPlaneCapabilitiesKHR &()
-    {
-      return *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>(this);
-    }
-
-    bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const
-    {
-      return ( supportedAlpha == rhs.supportedAlpha )
-          && ( minSrcPosition == rhs.minSrcPosition )
-          && ( maxSrcPosition == rhs.maxSrcPosition )
-          && ( minSrcExtent == rhs.minSrcExtent )
-          && ( maxSrcExtent == rhs.maxSrcExtent )
-          && ( minDstPosition == rhs.minDstPosition )
-          && ( maxDstPosition == rhs.maxDstPosition )
-          && ( minDstExtent == rhs.minDstExtent )
-          && ( maxDstExtent == rhs.maxDstExtent );
-    }
-
-    bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DisplayPlaneAlphaFlagsKHR supportedAlpha;
-    Offset2D minSrcPosition;
-    Offset2D maxSrcPosition;
-    Extent2D minSrcExtent;
-    Extent2D maxSrcExtent;
-    Offset2D minDstPosition;
-    Offset2D maxDstPosition;
-    Extent2D minDstExtent;
-    Extent2D maxDstExtent;
-  };
-  static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" );
-
-  struct DisplayPlaneCapabilities2KHR
-  {
-    operator VkDisplayPlaneCapabilities2KHR const&() const
-    {
-      return *reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>(this);
-    }
-
-    operator VkDisplayPlaneCapabilities2KHR &()
-    {
-      return *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>(this);
-    }
-
-    bool operator==( DisplayPlaneCapabilities2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( capabilities == rhs.capabilities );
-    }
-
-    bool operator!=( DisplayPlaneCapabilities2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR;
-
-  public:
-    void* pNext = nullptr;
-    DisplayPlaneCapabilitiesKHR capabilities;
-  };
-  static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" );
-
-  enum class CompositeAlphaFlagBitsKHR
-  {
-    eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
-    ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
-    ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
-    eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
-  };
-
-  using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR, VkCompositeAlphaFlagsKHR>;
-
-  VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
-  {
-    return CompositeAlphaFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits )
-  {
-    return ~( CompositeAlphaFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<CompositeAlphaFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) | VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::eInherit)
-    };
-  };
-
-  enum class SurfaceTransformFlagBitsKHR
-  {
-    eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
-    eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR,
-    eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR,
-    eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR,
-    eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR,
-    eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR,
-    eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR,
-    eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR,
-    eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR
-  };
-
-  using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR, VkSurfaceTransformFlagsKHR>;
-
-  VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
-  {
-    return SurfaceTransformFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits )
-  {
-    return ~( SurfaceTransformFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<SurfaceTransformFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eInherit)
-    };
-  };
-
-  struct DisplayPropertiesKHR
-  {
-    operator VkDisplayPropertiesKHR const&() const
-    {
-      return *reinterpret_cast<const VkDisplayPropertiesKHR*>(this);
-    }
-
-    operator VkDisplayPropertiesKHR &()
-    {
-      return *reinterpret_cast<VkDisplayPropertiesKHR*>(this);
-    }
-
-    bool operator==( DisplayPropertiesKHR const& rhs ) const
-    {
-      return ( display == rhs.display )
-          && ( displayName == rhs.displayName )
-          && ( physicalDimensions == rhs.physicalDimensions )
-          && ( physicalResolution == rhs.physicalResolution )
-          && ( supportedTransforms == rhs.supportedTransforms )
-          && ( planeReorderPossible == rhs.planeReorderPossible )
-          && ( persistentContent == rhs.persistentContent );
-    }
-
-    bool operator!=( DisplayPropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DisplayKHR display;
-    const char* displayName;
-    Extent2D physicalDimensions;
-    Extent2D physicalResolution;
-    SurfaceTransformFlagsKHR supportedTransforms;
-    Bool32 planeReorderPossible;
-    Bool32 persistentContent;
-  };
-  static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" );
-
-  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() )
-      : flags( flags_ )
-      , displayMode( displayMode_ )
-      , planeIndex( planeIndex_ )
-      , planeStackIndex( planeStackIndex_ )
-      , transform( transform_ )
-      , globalAlpha( globalAlpha_ )
-      , alphaMode( alphaMode_ )
-      , imageExtent( imageExtent_ )
-    {
-    }
-
-    DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
-    }
-
-    DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
-      return *this;
-    }
-    DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setFlags( DisplaySurfaceCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setDisplayMode( DisplayModeKHR displayMode_ )
-    {
-      displayMode = displayMode_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setPlaneIndex( uint32_t planeIndex_ )
-    {
-      planeIndex = planeIndex_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setPlaneStackIndex( uint32_t planeStackIndex_ )
-    {
-      planeStackIndex = planeStackIndex_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setTransform( SurfaceTransformFlagBitsKHR transform_ )
-    {
-      transform = transform_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setGlobalAlpha( float globalAlpha_ )
-    {
-      globalAlpha = globalAlpha_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ )
-    {
-      alphaMode = alphaMode_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
-    {
-      imageExtent = imageExtent_;
-      return *this;
-    }
-
-    operator VkDisplaySurfaceCreateInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(this);
-    }
-
-    operator VkDisplaySurfaceCreateInfoKHR &()
-    {
-      return *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>(this);
-    }
-
-    bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( displayMode == rhs.displayMode )
-          && ( planeIndex == rhs.planeIndex )
-          && ( planeStackIndex == rhs.planeStackIndex )
-          && ( transform == rhs.transform )
-          && ( globalAlpha == rhs.globalAlpha )
-          && ( alphaMode == rhs.alphaMode )
-          && ( imageExtent == rhs.imageExtent );
-    }
-
-    bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    DisplaySurfaceCreateFlagsKHR flags;
-    DisplayModeKHR displayMode;
-    uint32_t planeIndex;
-    uint32_t planeStackIndex;
-    SurfaceTransformFlagBitsKHR transform;
-    float globalAlpha;
-    DisplayPlaneAlphaFlagBitsKHR alphaMode;
-    Extent2D imageExtent;
-  };
-  static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  struct SurfaceCapabilitiesKHR
-  {
-    operator VkSurfaceCapabilitiesKHR const&() const
-    {
-      return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>(this);
-    }
-
-    operator VkSurfaceCapabilitiesKHR &()
-    {
-      return *reinterpret_cast<VkSurfaceCapabilitiesKHR*>(this);
-    }
-
-    bool operator==( SurfaceCapabilitiesKHR const& rhs ) const
-    {
-      return ( minImageCount == rhs.minImageCount )
-          && ( maxImageCount == rhs.maxImageCount )
-          && ( currentExtent == rhs.currentExtent )
-          && ( minImageExtent == rhs.minImageExtent )
-          && ( maxImageExtent == rhs.maxImageExtent )
-          && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
-          && ( supportedTransforms == rhs.supportedTransforms )
-          && ( currentTransform == rhs.currentTransform )
-          && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
-          && ( supportedUsageFlags == rhs.supportedUsageFlags );
-    }
-
-    bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t minImageCount;
-    uint32_t maxImageCount;
-    Extent2D currentExtent;
-    Extent2D minImageExtent;
-    Extent2D maxImageExtent;
-    uint32_t maxImageArrayLayers;
-    SurfaceTransformFlagsKHR supportedTransforms;
-    SurfaceTransformFlagBitsKHR currentTransform;
-    CompositeAlphaFlagsKHR supportedCompositeAlpha;
-    ImageUsageFlags supportedUsageFlags;
-  };
-  static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
-
-  struct SurfaceCapabilities2KHR
-  {
-    operator VkSurfaceCapabilities2KHR const&() const
-    {
-      return *reinterpret_cast<const VkSurfaceCapabilities2KHR*>(this);
-    }
-
-    operator VkSurfaceCapabilities2KHR &()
-    {
-      return *reinterpret_cast<VkSurfaceCapabilities2KHR*>(this);
-    }
-
-    bool operator==( SurfaceCapabilities2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( surfaceCapabilities == rhs.surfaceCapabilities );
-    }
-
-    bool operator!=( SurfaceCapabilities2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSurfaceCapabilities2KHR;
-
-  public:
-    void* pNext = nullptr;
-    SurfaceCapabilitiesKHR surfaceCapabilities;
-  };
-  static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" );
-
-  struct DisplayProperties2KHR
-  {
-    operator VkDisplayProperties2KHR const&() const
-    {
-      return *reinterpret_cast<const VkDisplayProperties2KHR*>(this);
-    }
-
-    operator VkDisplayProperties2KHR &()
-    {
-      return *reinterpret_cast<VkDisplayProperties2KHR*>(this);
-    }
-
-    bool operator==( DisplayProperties2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( displayProperties == rhs.displayProperties );
-    }
-
-    bool operator!=( DisplayProperties2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDisplayProperties2KHR;
-
-  public:
-    void* pNext = nullptr;
-    DisplayPropertiesKHR displayProperties;
-  };
-  static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" );
-
-  enum class TimeDomainEXT
-  {
-    eDevice = VK_TIME_DOMAIN_DEVICE_EXT,
-    eClockMonotonic = VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT,
-    eClockMonotonicRaw = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT,
-    eQueryPerformanceCounter = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT
-  };
-
-  struct CalibratedTimestampInfoEXT
-  {
-    CalibratedTimestampInfoEXT( TimeDomainEXT timeDomain_ = TimeDomainEXT::eDevice )
-      : timeDomain( timeDomain_ )
-    {
-    }
-
-    CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CalibratedTimestampInfoEXT ) );
-    }
-
-    CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CalibratedTimestampInfoEXT ) );
-      return *this;
-    }
-    CalibratedTimestampInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CalibratedTimestampInfoEXT& setTimeDomain( TimeDomainEXT timeDomain_ )
-    {
-      timeDomain = timeDomain_;
-      return *this;
-    }
-
-    operator VkCalibratedTimestampInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkCalibratedTimestampInfoEXT*>(this);
-    }
-
-    operator VkCalibratedTimestampInfoEXT &()
-    {
-      return *reinterpret_cast<VkCalibratedTimestampInfoEXT*>(this);
-    }
-
-    bool operator==( CalibratedTimestampInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( timeDomain == rhs.timeDomain );
-    }
-
-    bool operator!=( CalibratedTimestampInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCalibratedTimestampInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    TimeDomainEXT timeDomain;
-  };
-  static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class DebugReportFlagBitsEXT
-  {
-    eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
-    eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT,
-    ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
-    eError = VK_DEBUG_REPORT_ERROR_BIT_EXT,
-    eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT
-  };
-
-  using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT, VkDebugReportFlagsEXT>;
-
-  VULKAN_HPP_INLINE DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
-  {
-    return DebugReportFlagsEXT( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits )
-  {
-    return ~( DebugReportFlagsEXT( bits ) );
-  }
-
-  template <> struct FlagTraits<DebugReportFlagBitsEXT>
-  {
-    enum
-    {
-      allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) | VkFlags(DebugReportFlagBitsEXT::eWarning) | VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) | VkFlags(DebugReportFlagBitsEXT::eError) | VkFlags(DebugReportFlagBitsEXT::eDebug)
-    };
-  };
-
-  struct DebugReportCallbackCreateInfoEXT
-  {
-    DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(),
-                                      PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr,
-                                      void* pUserData_ = nullptr )
-      : flags( flags_ )
-      , pfnCallback( pfnCallback_ )
-      , pUserData( pUserData_ )
-    {
-    }
-
-    DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
-    }
-
-    DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
-      return *this;
-    }
-    DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DebugReportCallbackCreateInfoEXT& setFlags( DebugReportFlagsEXT flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DebugReportCallbackCreateInfoEXT& setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ )
-    {
-      pfnCallback = pfnCallback_;
-      return *this;
-    }
-
-    DebugReportCallbackCreateInfoEXT& setPUserData( void* pUserData_ )
-    {
-      pUserData = pUserData_;
-      return *this;
-    }
-
-    operator VkDebugReportCallbackCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(this);
-    }
-
-    operator VkDebugReportCallbackCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(this);
-    }
-
-    bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( pfnCallback == rhs.pfnCallback )
-          && ( pUserData == rhs.pUserData );
-    }
-
-    bool operator!=( DebugReportCallbackCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DebugReportFlagsEXT flags;
-    PFN_vkDebugReportCallbackEXT pfnCallback;
-    void* pUserData;
-  };
-  static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class DebugReportObjectTypeEXT
-  {
-    eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
-    eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
-    ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
-    eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
-    eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
-    eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
-    eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-    eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
-    eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
-    eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
-    eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-    eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
-    eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT,
-    eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT,
-    eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
-    eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT,
-    ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT,
-    ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT,
-    eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
-    ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
-    eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT,
-    eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT,
-    eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
-    eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
-    eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT,
-    eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT,
-    eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT,
-    eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
-    eDebugReportCallbackExt = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
-    eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
-    eDisplayKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT,
-    eDisplayModeKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT,
-    eObjectTableNvx = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT,
-    eIndirectCommandsLayoutNvx = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT,
-    eValidationCacheExt = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
-    eValidationCache = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
-    eSamplerYcbcrConversion = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
-    eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
-    eDescriptorUpdateTemplate = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
-    eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
-    eAccelerationStructureNV = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT
-  };
-
-  struct DebugMarkerObjectNameInfoEXT
-  {
-    DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown,
-                                  uint64_t object_ = 0,
-                                  const char* pObjectName_ = nullptr )
-      : objectType( objectType_ )
-      , object( object_ )
-      , pObjectName( pObjectName_ )
-    {
-    }
-
-    DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
-    }
-
-    DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
-      return *this;
-    }
-    DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DebugMarkerObjectNameInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
-    {
-      objectType = objectType_;
-      return *this;
-    }
-
-    DebugMarkerObjectNameInfoEXT& setObject( uint64_t object_ )
-    {
-      object = object_;
-      return *this;
-    }
-
-    DebugMarkerObjectNameInfoEXT& setPObjectName( const char* pObjectName_ )
-    {
-      pObjectName = pObjectName_;
-      return *this;
-    }
-
-    operator VkDebugMarkerObjectNameInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(this);
-    }
-
-    operator VkDebugMarkerObjectNameInfoEXT &()
-    {
-      return *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(this);
-    }
-
-    bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( objectType == rhs.objectType )
-          && ( object == rhs.object )
-          && ( pObjectName == rhs.pObjectName );
-    }
-
-    bool operator!=( DebugMarkerObjectNameInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DebugReportObjectTypeEXT objectType;
-    uint64_t object;
-    const char* pObjectName;
-  };
-  static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" );
-
-  struct DebugMarkerObjectTagInfoEXT
-  {
-    DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown,
-                                 uint64_t object_ = 0,
-                                 uint64_t tagName_ = 0,
-                                 size_t tagSize_ = 0,
-                                 const void* pTag_ = nullptr )
-      : objectType( objectType_ )
-      , object( object_ )
-      , tagName( tagName_ )
-      , tagSize( tagSize_ )
-      , pTag( pTag_ )
-    {
-    }
-
-    DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
-    }
-
-    DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
-      return *this;
-    }
-    DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DebugMarkerObjectTagInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
-    {
-      objectType = objectType_;
-      return *this;
-    }
-
-    DebugMarkerObjectTagInfoEXT& setObject( uint64_t object_ )
-    {
-      object = object_;
-      return *this;
-    }
-
-    DebugMarkerObjectTagInfoEXT& setTagName( uint64_t tagName_ )
-    {
-      tagName = tagName_;
-      return *this;
-    }
-
-    DebugMarkerObjectTagInfoEXT& setTagSize( size_t tagSize_ )
-    {
-      tagSize = tagSize_;
-      return *this;
-    }
-
-    DebugMarkerObjectTagInfoEXT& setPTag( const void* pTag_ )
-    {
-      pTag = pTag_;
-      return *this;
-    }
-
-    operator VkDebugMarkerObjectTagInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(this);
-    }
-
-    operator VkDebugMarkerObjectTagInfoEXT &()
-    {
-      return *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>(this);
-    }
-
-    bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( objectType == rhs.objectType )
-          && ( object == rhs.object )
-          && ( tagName == rhs.tagName )
-          && ( tagSize == rhs.tagSize )
-          && ( pTag == rhs.pTag );
-    }
-
-    bool operator!=( DebugMarkerObjectTagInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DebugReportObjectTypeEXT objectType;
-    uint64_t object;
-    uint64_t tagName;
-    size_t tagSize;
-    const void* pTag;
-  };
-  static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class RasterizationOrderAMD
-  {
-    eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD,
-    eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD
-  };
-
-  struct PipelineRasterizationStateRasterizationOrderAMD
-  {
-    PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict )
-      : rasterizationOrder( rasterizationOrder_ )
-    {
-    }
-
-    PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
-    }
-
-    PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
-      return *this;
-    }
-    PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineRasterizationStateRasterizationOrderAMD& setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ )
-    {
-      rasterizationOrder = rasterizationOrder_;
-      return *this;
-    }
-
-    operator VkPipelineRasterizationStateRasterizationOrderAMD const&() const
-    {
-      return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
-    }
-
-    operator VkPipelineRasterizationStateRasterizationOrderAMD &()
-    {
-      return *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
-    }
-
-    bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( rasterizationOrder == rhs.rasterizationOrder );
-    }
-
-    bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
-
-  public:
-    const void* pNext = nullptr;
-    RasterizationOrderAMD rasterizationOrder;
-  };
-  static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
-
-  enum class ExternalMemoryHandleTypeFlagBitsNV
-  {
-    eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV,
-    eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV,
-    eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV,
-    eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV
-  };
-
-  using ExternalMemoryHandleTypeFlagsNV = Flags<ExternalMemoryHandleTypeFlagBitsNV, VkExternalMemoryHandleTypeFlagsNV>;
-
-  VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
-  {
-    return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits )
-  {
-    return ~( ExternalMemoryHandleTypeFlagsNV( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsNV>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt)
-    };
-  };
-
-  struct ExternalMemoryImageCreateInfoNV
-  {
-    ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
-    }
-
-    ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
-      return *this;
-    }
-    ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExternalMemoryImageCreateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator VkExternalMemoryImageCreateInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(this);
-    }
-
-    operator VkExternalMemoryImageCreateInfoNV &()
-    {
-      return *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(this);
-    }
-
-    bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagsNV handleTypes;
-  };
-  static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
-
-  struct ExportMemoryAllocateInfoNV
-  {
-    ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
-    }
-
-    ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
-      return *this;
-    }
-    ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportMemoryAllocateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator VkExportMemoryAllocateInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(this);
-    }
-
-    operator VkExportMemoryAllocateInfoNV &()
-    {
-      return *reinterpret_cast<VkExportMemoryAllocateInfoNV*>(this);
-    }
-
-    bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportMemoryAllocateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagsNV handleTypes;
-  };
-  static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ImportMemoryWin32HandleInfoNV
-  {
-    ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(),
-                                   HANDLE handle_ = 0 )
-      : handleType( handleType_ )
-      , handle( handle_ )
-    {
-    }
-
-    ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
-    }
-
-    ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
-      return *this;
-    }
-    ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ )
-    {
-      handle = handle_;
-      return *this;
-    }
-
-    operator VkImportMemoryWin32HandleInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(this);
-    }
-
-    operator VkImportMemoryWin32HandleInfoNV &()
-    {
-      return *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(this);
-    }
-
-    bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType )
-          && ( handle == rhs.handle );
-    }
-
-    bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagsNV handleType;
-    HANDLE handle;
-  };
-  static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  enum class ExternalMemoryFeatureFlagBitsNV
-  {
-    eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV,
-    eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV,
-    eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV
-  };
-
-  using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV, VkExternalMemoryFeatureFlagsNV>;
-
-  VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
-  {
-    return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits )
-  {
-    return ~( ExternalMemoryFeatureFlagsNV( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsNV>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable)
-    };
-  };
-
-  struct ExternalImageFormatPropertiesNV
-  {
-    operator VkExternalImageFormatPropertiesNV const&() const
-    {
-      return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>(this);
-    }
-
-    operator VkExternalImageFormatPropertiesNV &()
-    {
-      return *reinterpret_cast<VkExternalImageFormatPropertiesNV*>(this);
-    }
-
-    bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const
-    {
-      return ( imageFormatProperties == rhs.imageFormatProperties )
-          && ( externalMemoryFeatures == rhs.externalMemoryFeatures )
-          && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
-          && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
-    }
-
-    bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageFormatProperties imageFormatProperties;
-    ExternalMemoryFeatureFlagsNV externalMemoryFeatures;
-    ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
-    ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
-  };
-  static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" );
-
-  enum class ValidationCheckEXT
-  {
-    eAll = VK_VALIDATION_CHECK_ALL_EXT,
-    eShaders = VK_VALIDATION_CHECK_SHADERS_EXT
-  };
-
-  struct ValidationFlagsEXT
-  {
-    ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0,
-                        const ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
-      : disabledValidationCheckCount( disabledValidationCheckCount_ )
-      , pDisabledValidationChecks( pDisabledValidationChecks_ )
-    {
-    }
-
-    ValidationFlagsEXT( VkValidationFlagsEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
-    }
-
-    ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
-      return *this;
-    }
-    ValidationFlagsEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ValidationFlagsEXT& setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ )
-    {
-      disabledValidationCheckCount = disabledValidationCheckCount_;
-      return *this;
-    }
-
-    ValidationFlagsEXT& setPDisabledValidationChecks( const ValidationCheckEXT* pDisabledValidationChecks_ )
-    {
-      pDisabledValidationChecks = pDisabledValidationChecks_;
-      return *this;
-    }
-
-    operator VkValidationFlagsEXT const&() const
-    {
-      return *reinterpret_cast<const VkValidationFlagsEXT*>(this);
-    }
-
-    operator VkValidationFlagsEXT &()
-    {
-      return *reinterpret_cast<VkValidationFlagsEXT*>(this);
-    }
-
-    bool operator==( ValidationFlagsEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount )
-          && ( pDisabledValidationChecks == rhs.pDisabledValidationChecks );
-    }
-
-    bool operator!=( ValidationFlagsEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eValidationFlagsEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t disabledValidationCheckCount;
-    const ValidationCheckEXT* pDisabledValidationChecks;
-  };
-  static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" );
-
-  enum class SubgroupFeatureFlagBits
-  {
-    eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT,
-    eVote = VK_SUBGROUP_FEATURE_VOTE_BIT,
-    eArithmetic = VK_SUBGROUP_FEATURE_ARITHMETIC_BIT,
-    eBallot = VK_SUBGROUP_FEATURE_BALLOT_BIT,
-    eShuffle = VK_SUBGROUP_FEATURE_SHUFFLE_BIT,
-    eShuffleRelative = VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT,
-    eClustered = VK_SUBGROUP_FEATURE_CLUSTERED_BIT,
-    eQuad = VK_SUBGROUP_FEATURE_QUAD_BIT,
-    ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV
-  };
-
-  using SubgroupFeatureFlags = Flags<SubgroupFeatureFlagBits, VkSubgroupFeatureFlags>;
-
-  VULKAN_HPP_INLINE SubgroupFeatureFlags operator|( SubgroupFeatureFlagBits bit0, SubgroupFeatureFlagBits bit1 )
-  {
-    return SubgroupFeatureFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SubgroupFeatureFlags operator~( SubgroupFeatureFlagBits bits )
-  {
-    return ~( SubgroupFeatureFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<SubgroupFeatureFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(SubgroupFeatureFlagBits::eBasic) | VkFlags(SubgroupFeatureFlagBits::eVote) | VkFlags(SubgroupFeatureFlagBits::eArithmetic) | VkFlags(SubgroupFeatureFlagBits::eBallot) | VkFlags(SubgroupFeatureFlagBits::eShuffle) | VkFlags(SubgroupFeatureFlagBits::eShuffleRelative) | VkFlags(SubgroupFeatureFlagBits::eClustered) | VkFlags(SubgroupFeatureFlagBits::eQuad) | VkFlags(SubgroupFeatureFlagBits::ePartitionedNV)
-    };
+    ImageUsageFlags usage;
+    ImageTiling tiling;
   };
+  static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "struct and wrapper have different size!" );
 
   struct PhysicalDeviceSubgroupProperties
   {
     operator VkPhysicalDeviceSubgroupProperties const&() const
     {
-      return *reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(this);
+      return *reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>( this );
     }
 
     operator VkPhysicalDeviceSubgroupProperties &()
     {
-      return *reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(this);
+      return *reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>( this );
     }
 
     bool operator==( PhysicalDeviceSubgroupProperties const& rhs ) const
@@ -30826,3996 +38253,1832 @@ public:
   };
   static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "struct and wrapper have different size!" );
 
-  enum class IndirectCommandsLayoutUsageFlagBitsNVX
+  struct PhysicalDeviceSurfaceInfo2KHR
   {
-    eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX,
-    eSparseSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX,
-    eEmptyExecutions = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX,
-    eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX
-  };
-
-  using IndirectCommandsLayoutUsageFlagsNVX = Flags<IndirectCommandsLayoutUsageFlagBitsNVX, VkIndirectCommandsLayoutUsageFlagsNVX>;
-
-  VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 )
-  {
-    return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits )
-  {
-    return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) );
-  }
-
-  template <> struct FlagTraits<IndirectCommandsLayoutUsageFlagBitsNVX>
-  {
-    enum
-    {
-      allFlags = VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences)
-    };
-  };
-
-  enum class ObjectEntryUsageFlagBitsNVX
-  {
-    eGraphics = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX,
-    eCompute = VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX
-  };
-
-  using ObjectEntryUsageFlagsNVX = Flags<ObjectEntryUsageFlagBitsNVX, VkObjectEntryUsageFlagsNVX>;
-
-  VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 )
-  {
-    return ObjectEntryUsageFlagsNVX( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits )
-  {
-    return ~( ObjectEntryUsageFlagsNVX( bits ) );
-  }
-
-  template <> struct FlagTraits<ObjectEntryUsageFlagBitsNVX>
-  {
-    enum
-    {
-      allFlags = VkFlags(ObjectEntryUsageFlagBitsNVX::eGraphics) | VkFlags(ObjectEntryUsageFlagBitsNVX::eCompute)
-    };
-  };
-
-  enum class IndirectCommandsTokenTypeNVX
-  {
-    ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX,
-    eDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX,
-    eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX,
-    eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX,
-    ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX,
-    eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX,
-    eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX,
-    eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX
-  };
-
-  struct IndirectCommandsTokenNVX
-  {
-    IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline,
-                              Buffer buffer_ = Buffer(),
-                              DeviceSize offset_ = 0 )
-      : tokenType( tokenType_ )
-      , buffer( buffer_ )
-      , offset( offset_ )
-    {
-    }
-
-    IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
-    }
-
-    IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
-      return *this;
-    }
-    IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
-    {
-      tokenType = tokenType_;
-      return *this;
-    }
-
-    IndirectCommandsTokenNVX& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    IndirectCommandsTokenNVX& setOffset( DeviceSize offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    operator VkIndirectCommandsTokenNVX const&() const
-    {
-      return *reinterpret_cast<const VkIndirectCommandsTokenNVX*>(this);
-    }
-
-    operator VkIndirectCommandsTokenNVX &()
-    {
-      return *reinterpret_cast<VkIndirectCommandsTokenNVX*>(this);
-    }
-
-    bool operator==( IndirectCommandsTokenNVX const& rhs ) const
-    {
-      return ( tokenType == rhs.tokenType )
-          && ( buffer == rhs.buffer )
-          && ( offset == rhs.offset );
-    }
-
-    bool operator!=( IndirectCommandsTokenNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    IndirectCommandsTokenTypeNVX tokenType;
-    Buffer buffer;
-    DeviceSize offset;
-  };
-  static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" );
-
-  struct IndirectCommandsLayoutTokenNVX
-  {
-    IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline,
-                                    uint32_t bindingUnit_ = 0,
-                                    uint32_t dynamicCount_ = 0,
-                                    uint32_t divisor_ = 0 )
-      : tokenType( tokenType_ )
-      , bindingUnit( bindingUnit_ )
-      , dynamicCount( dynamicCount_ )
-      , divisor( divisor_ )
-    {
-    }
-
-    IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
-    }
-
-    IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
-      return *this;
-    }
-    IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
-    {
-      tokenType = tokenType_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutTokenNVX& setBindingUnit( uint32_t bindingUnit_ )
-    {
-      bindingUnit = bindingUnit_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutTokenNVX& setDynamicCount( uint32_t dynamicCount_ )
-    {
-      dynamicCount = dynamicCount_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutTokenNVX& setDivisor( uint32_t divisor_ )
-    {
-      divisor = divisor_;
-      return *this;
-    }
-
-    operator VkIndirectCommandsLayoutTokenNVX const&() const
-    {
-      return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNVX*>(this);
-    }
-
-    operator VkIndirectCommandsLayoutTokenNVX &()
-    {
-      return *reinterpret_cast<VkIndirectCommandsLayoutTokenNVX*>(this);
-    }
-
-    bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const
-    {
-      return ( tokenType == rhs.tokenType )
-          && ( bindingUnit == rhs.bindingUnit )
-          && ( dynamicCount == rhs.dynamicCount )
-          && ( divisor == rhs.divisor );
-    }
-
-    bool operator!=( IndirectCommandsLayoutTokenNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    IndirectCommandsTokenTypeNVX tokenType;
-    uint32_t bindingUnit;
-    uint32_t dynamicCount;
-    uint32_t divisor;
-  };
-  static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" );
-
-  struct IndirectCommandsLayoutCreateInfoNVX
-  {
-    IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
-                                         IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(),
-                                         uint32_t tokenCount_ = 0,
-                                         const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
-      : pipelineBindPoint( pipelineBindPoint_ )
-      , flags( flags_ )
-      , tokenCount( tokenCount_ )
-      , pTokens( pTokens_ )
-    {
-    }
-
-    IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
-    }
-
-    IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
-      return *this;
-    }
-    IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutCreateInfoNVX& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
-    {
-      pipelineBindPoint = pipelineBindPoint_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutCreateInfoNVX& setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutCreateInfoNVX& setTokenCount( uint32_t tokenCount_ )
-    {
-      tokenCount = tokenCount_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutCreateInfoNVX& setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ )
-    {
-      pTokens = pTokens_;
-      return *this;
-    }
-
-    operator VkIndirectCommandsLayoutCreateInfoNVX const&() const
-    {
-      return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>(this);
-    }
-
-    operator VkIndirectCommandsLayoutCreateInfoNVX &()
-    {
-      return *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX*>(this);
-    }
-
-    bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pipelineBindPoint == rhs.pipelineBindPoint )
-          && ( flags == rhs.flags )
-          && ( tokenCount == rhs.tokenCount )
-          && ( pTokens == rhs.pTokens );
-    }
-
-    bool operator!=( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineBindPoint pipelineBindPoint;
-    IndirectCommandsLayoutUsageFlagsNVX flags;
-    uint32_t tokenCount;
-    const IndirectCommandsLayoutTokenNVX* pTokens;
-  };
-  static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" );
-
-  enum class ObjectEntryTypeNVX
-  {
-    eDescriptorSet = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX,
-    ePipeline = VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX,
-    eIndexBuffer = VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX,
-    eVertexBuffer = VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX,
-    ePushConstant = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX
-  };
-
-  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 )
-      : objectCount( objectCount_ )
-      , pObjectEntryTypes( pObjectEntryTypes_ )
-      , pObjectEntryCounts( pObjectEntryCounts_ )
-      , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
-      , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
-      , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
-      , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
-      , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
-      , maxPipelineLayouts( maxPipelineLayouts_ )
-    {
-    }
-
-    ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
-    }
-
-    ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
-      return *this;
-    }
-    ObjectTableCreateInfoNVX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setObjectCount( uint32_t objectCount_ )
-    {
-      objectCount = objectCount_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ )
-    {
-      pObjectEntryTypes = pObjectEntryTypes_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setPObjectEntryCounts( const uint32_t* pObjectEntryCounts_ )
-    {
-      pObjectEntryCounts = pObjectEntryCounts_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ )
-    {
-      pObjectEntryUsageFlags = pObjectEntryUsageFlags_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setMaxUniformBuffersPerDescriptor( uint32_t maxUniformBuffersPerDescriptor_ )
-    {
-      maxUniformBuffersPerDescriptor = maxUniformBuffersPerDescriptor_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setMaxStorageBuffersPerDescriptor( uint32_t maxStorageBuffersPerDescriptor_ )
-    {
-      maxStorageBuffersPerDescriptor = maxStorageBuffersPerDescriptor_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setMaxStorageImagesPerDescriptor( uint32_t maxStorageImagesPerDescriptor_ )
-    {
-      maxStorageImagesPerDescriptor = maxStorageImagesPerDescriptor_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setMaxSampledImagesPerDescriptor( uint32_t maxSampledImagesPerDescriptor_ )
-    {
-      maxSampledImagesPerDescriptor = maxSampledImagesPerDescriptor_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setMaxPipelineLayouts( uint32_t maxPipelineLayouts_ )
-    {
-      maxPipelineLayouts = maxPipelineLayouts_;
-      return *this;
-    }
-
-    operator VkObjectTableCreateInfoNVX const&() const
-    {
-      return *reinterpret_cast<const VkObjectTableCreateInfoNVX*>(this);
-    }
-
-    operator VkObjectTableCreateInfoNVX &()
-    {
-      return *reinterpret_cast<VkObjectTableCreateInfoNVX*>(this);
-    }
-
-    bool operator==( ObjectTableCreateInfoNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( objectCount == rhs.objectCount )
-          && ( pObjectEntryTypes == rhs.pObjectEntryTypes )
-          && ( pObjectEntryCounts == rhs.pObjectEntryCounts )
-          && ( pObjectEntryUsageFlags == rhs.pObjectEntryUsageFlags )
-          && ( maxUniformBuffersPerDescriptor == rhs.maxUniformBuffersPerDescriptor )
-          && ( maxStorageBuffersPerDescriptor == rhs.maxStorageBuffersPerDescriptor )
-          && ( maxStorageImagesPerDescriptor == rhs.maxStorageImagesPerDescriptor )
-          && ( maxSampledImagesPerDescriptor == rhs.maxSampledImagesPerDescriptor )
-          && ( maxPipelineLayouts == rhs.maxPipelineLayouts );
-    }
-
-    bool operator!=( ObjectTableCreateInfoNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eObjectTableCreateInfoNVX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t objectCount;
-    const ObjectEntryTypeNVX* pObjectEntryTypes;
-    const uint32_t* pObjectEntryCounts;
-    const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
-    uint32_t maxUniformBuffersPerDescriptor;
-    uint32_t maxStorageBuffersPerDescriptor;
-    uint32_t maxStorageImagesPerDescriptor;
-    uint32_t maxSampledImagesPerDescriptor;
-    uint32_t maxPipelineLayouts;
-  };
-  static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" );
-
-  struct ObjectTableEntryNVX
-  {
-    ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
-                         ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() )
-      : type( type_ )
-      , flags( flags_ )
-    {
-    }
-
-    ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
-    }
-
-    ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
-      return *this;
-    }
-    ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    ObjectTableEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator VkObjectTableEntryNVX const&() const
-    {
-      return *reinterpret_cast<const VkObjectTableEntryNVX*>(this);
-    }
-
-    operator VkObjectTableEntryNVX &()
-    {
-      return *reinterpret_cast<VkObjectTableEntryNVX*>(this);
-    }
-
-    bool operator==( ObjectTableEntryNVX const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( ObjectTableEntryNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-  };
-  static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" );
-
-  struct ObjectTablePipelineEntryNVX
-  {
-    ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
-                                 ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
-                                 Pipeline pipeline_ = Pipeline() )
-      : type( type_ )
-      , flags( flags_ )
-      , pipeline( pipeline_ )
-    {
-    }
-
-    explicit ObjectTablePipelineEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
-                                          Pipeline pipeline_ = Pipeline() )
-      : type( objectTableEntryNVX.type )
-      , flags( objectTableEntryNVX.flags )
-      , pipeline( pipeline_ )
+    PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = SurfaceKHR() )
+      : surface( surface_ )
     {}
 
-    ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs )
+    PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
     {
-      memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
+      memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) );
     }
 
-    ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs )
+    PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
     {
-      memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
-      return *this;
-    }
-    ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ )
-    {
-      type = type_;
+      memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) );
       return *this;
     }
 
-    ObjectTablePipelineEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ObjectTablePipelineEntryNVX& setPipeline( Pipeline pipeline_ )
-    {
-      pipeline = pipeline_;
-      return *this;
-    }
-
-    operator VkObjectTablePipelineEntryNVX const&() const
-    {
-      return *reinterpret_cast<const VkObjectTablePipelineEntryNVX*>(this);
-    }
-
-    operator VkObjectTablePipelineEntryNVX &()
-    {
-      return *reinterpret_cast<VkObjectTablePipelineEntryNVX*>(this);
-    }
-
-    bool operator==( ObjectTablePipelineEntryNVX const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( flags == rhs.flags )
-          && ( pipeline == rhs.pipeline );
-    }
-
-    bool operator!=( ObjectTablePipelineEntryNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    Pipeline pipeline;
-  };
-  static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" );
-
-  struct ObjectTableDescriptorSetEntryNVX
-  {
-    ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
-                                      ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
-                                      PipelineLayout pipelineLayout_ = PipelineLayout(),
-                                      DescriptorSet descriptorSet_ = DescriptorSet() )
-      : type( type_ )
-      , flags( flags_ )
-      , pipelineLayout( pipelineLayout_ )
-      , descriptorSet( descriptorSet_ )
-    {
-    }
-
-    explicit ObjectTableDescriptorSetEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
-                                               PipelineLayout pipelineLayout_ = PipelineLayout(),
-                                               DescriptorSet descriptorSet_ = DescriptorSet() )
-      : type( objectTableEntryNVX.type )
-      , flags( objectTableEntryNVX.flags )
-      , pipelineLayout( pipelineLayout_ )
-      , descriptorSet( descriptorSet_ )
-    {}
-
-    ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
-    }
-
-    ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
-      return *this;
-    }
-    ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    ObjectTableDescriptorSetEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ObjectTableDescriptorSetEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ )
-    {
-      pipelineLayout = pipelineLayout_;
-      return *this;
-    }
-
-    ObjectTableDescriptorSetEntryNVX& setDescriptorSet( DescriptorSet descriptorSet_ )
-    {
-      descriptorSet = descriptorSet_;
-      return *this;
-    }
-
-    operator VkObjectTableDescriptorSetEntryNVX const&() const
-    {
-      return *reinterpret_cast<const VkObjectTableDescriptorSetEntryNVX*>(this);
-    }
-
-    operator VkObjectTableDescriptorSetEntryNVX &()
-    {
-      return *reinterpret_cast<VkObjectTableDescriptorSetEntryNVX*>(this);
-    }
-
-    bool operator==( ObjectTableDescriptorSetEntryNVX const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( flags == rhs.flags )
-          && ( pipelineLayout == rhs.pipelineLayout )
-          && ( descriptorSet == rhs.descriptorSet );
-    }
-
-    bool operator!=( ObjectTableDescriptorSetEntryNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    PipelineLayout pipelineLayout;
-    DescriptorSet descriptorSet;
-  };
-  static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" );
-
-  struct ObjectTableVertexBufferEntryNVX
-  {
-    ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
-                                     ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
-                                     Buffer buffer_ = Buffer() )
-      : type( type_ )
-      , flags( flags_ )
-      , buffer( buffer_ )
-    {
-    }
-
-    explicit ObjectTableVertexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
-                                              Buffer buffer_ = Buffer() )
-      : type( objectTableEntryNVX.type )
-      , flags( objectTableEntryNVX.flags )
-      , buffer( buffer_ )
-    {}
-
-    ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
-    }
-
-    ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
-      return *this;
-    }
-    ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    ObjectTableVertexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ObjectTableVertexBufferEntryNVX& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    operator VkObjectTableVertexBufferEntryNVX const&() const
-    {
-      return *reinterpret_cast<const VkObjectTableVertexBufferEntryNVX*>(this);
-    }
-
-    operator VkObjectTableVertexBufferEntryNVX &()
-    {
-      return *reinterpret_cast<VkObjectTableVertexBufferEntryNVX*>(this);
-    }
-
-    bool operator==( ObjectTableVertexBufferEntryNVX const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( flags == rhs.flags )
-          && ( buffer == rhs.buffer );
-    }
-
-    bool operator!=( ObjectTableVertexBufferEntryNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    Buffer buffer;
-  };
-  static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" );
-
-  struct ObjectTableIndexBufferEntryNVX
-  {
-    ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
-                                    ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
-                                    Buffer buffer_ = Buffer(),
-                                    IndexType indexType_ = IndexType::eUint16 )
-      : type( type_ )
-      , flags( flags_ )
-      , buffer( buffer_ )
-      , indexType( indexType_ )
-    {
-    }
-
-    explicit ObjectTableIndexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
-                                             Buffer buffer_ = Buffer(),
-                                             IndexType indexType_ = IndexType::eUint16 )
-      : type( objectTableEntryNVX.type )
-      , flags( objectTableEntryNVX.flags )
-      , buffer( buffer_ )
-      , indexType( indexType_ )
-    {}
-
-    ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
-    }
-
-    ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
-      return *this;
-    }
-    ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    ObjectTableIndexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ObjectTableIndexBufferEntryNVX& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    ObjectTableIndexBufferEntryNVX& setIndexType( IndexType indexType_ )
-    {
-      indexType = indexType_;
-      return *this;
-    }
-
-    operator VkObjectTableIndexBufferEntryNVX const&() const
-    {
-      return *reinterpret_cast<const VkObjectTableIndexBufferEntryNVX*>(this);
-    }
-
-    operator VkObjectTableIndexBufferEntryNVX &()
-    {
-      return *reinterpret_cast<VkObjectTableIndexBufferEntryNVX*>(this);
-    }
-
-    bool operator==( ObjectTableIndexBufferEntryNVX const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( flags == rhs.flags )
-          && ( buffer == rhs.buffer )
-          && ( indexType == rhs.indexType );
-    }
-
-    bool operator!=( ObjectTableIndexBufferEntryNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    Buffer buffer;
-    IndexType indexType;
-  };
-  static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" );
-
-  struct ObjectTablePushConstantEntryNVX
-  {
-    ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
-                                     ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
-                                     PipelineLayout pipelineLayout_ = PipelineLayout(),
-                                     ShaderStageFlags stageFlags_ = ShaderStageFlags() )
-      : type( type_ )
-      , flags( flags_ )
-      , pipelineLayout( pipelineLayout_ )
-      , stageFlags( stageFlags_ )
-    {
-    }
-
-    explicit ObjectTablePushConstantEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
-                                              PipelineLayout pipelineLayout_ = PipelineLayout(),
-                                              ShaderStageFlags stageFlags_ = ShaderStageFlags() )
-      : type( objectTableEntryNVX.type )
-      , flags( objectTableEntryNVX.flags )
-      , pipelineLayout( pipelineLayout_ )
-      , stageFlags( stageFlags_ )
-    {}
-
-    ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
-    }
-
-    ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
-      return *this;
-    }
-    ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    ObjectTablePushConstantEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ObjectTablePushConstantEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ )
-    {
-      pipelineLayout = pipelineLayout_;
-      return *this;
-    }
-
-    ObjectTablePushConstantEntryNVX& setStageFlags( ShaderStageFlags stageFlags_ )
-    {
-      stageFlags = stageFlags_;
-      return *this;
-    }
-
-    operator VkObjectTablePushConstantEntryNVX const&() const
-    {
-      return *reinterpret_cast<const VkObjectTablePushConstantEntryNVX*>(this);
-    }
-
-    operator VkObjectTablePushConstantEntryNVX &()
-    {
-      return *reinterpret_cast<VkObjectTablePushConstantEntryNVX*>(this);
-    }
-
-    bool operator==( ObjectTablePushConstantEntryNVX const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( flags == rhs.flags )
-          && ( pipelineLayout == rhs.pipelineLayout )
-          && ( stageFlags == rhs.stageFlags );
-    }
-
-    bool operator!=( ObjectTablePushConstantEntryNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    PipelineLayout pipelineLayout;
-    ShaderStageFlags stageFlags;
-  };
-  static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" );
-
-  enum class DescriptorSetLayoutCreateFlagBits
-  {
-    ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR,
-    eUpdateAfterBindPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT
-  };
-
-  using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits, VkDescriptorSetLayoutCreateFlags>;
-
-  VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
-  {
-    return DescriptorSetLayoutCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator~( DescriptorSetLayoutCreateFlagBits bits )
-  {
-    return ~( DescriptorSetLayoutCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<DescriptorSetLayoutCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) | VkFlags(DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT)
-    };
-  };
-
-  struct DescriptorSetLayoutCreateInfo
-  {
-    DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(),
-                                   uint32_t bindingCount_ = 0,
-                                   const DescriptorSetLayoutBinding* pBindings_ = nullptr )
-      : flags( flags_ )
-      , bindingCount( bindingCount_ )
-      , pBindings( pBindings_ )
-    {
-    }
-
-    DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
-    }
-
-    DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
-      return *this;
-    }
-    DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ )
+    PhysicalDeviceSurfaceInfo2KHR & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    DescriptorSetLayoutCreateInfo& setFlags( DescriptorSetLayoutCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DescriptorSetLayoutCreateInfo& setBindingCount( uint32_t bindingCount_ )
-    {
-      bindingCount = bindingCount_;
-      return *this;
-    }
-
-    DescriptorSetLayoutCreateInfo& setPBindings( const DescriptorSetLayoutBinding* pBindings_ )
-    {
-      pBindings = pBindings_;
-      return *this;
-    }
-
-    operator VkDescriptorSetLayoutCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(this);
-    }
-
-    operator VkDescriptorSetLayoutCreateInfo &()
-    {
-      return *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>(this);
-    }
-
-    bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( bindingCount == rhs.bindingCount )
-          && ( pBindings == rhs.pBindings );
-    }
-
-    bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorSetLayoutCreateFlags flags;
-    uint32_t bindingCount;
-    const DescriptorSetLayoutBinding* pBindings;
-  };
-  static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class ExternalMemoryHandleTypeFlagBits
-  {
-    eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
-    eOpaqueFdKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
-    eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
-    eOpaqueWin32KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
-    eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
-    eOpaqueWin32KmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
-    eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
-    eD3D11TextureKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
-    eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
-    eD3D11TextureKmtKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
-    eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
-    eD3D12HeapKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
-    eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
-    eD3D12ResourceKHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
-    eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
-    eAndroidHardwareBufferANDROID = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
-    eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
-    eHostMappedForeignMemoryEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT
-  };
-
-  using ExternalMemoryHandleTypeFlags = Flags<ExternalMemoryHandleTypeFlagBits, VkExternalMemoryHandleTypeFlags>;
-
-  VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator|( ExternalMemoryHandleTypeFlagBits bit0, ExternalMemoryHandleTypeFlagBits bit1 )
-  {
-    return ExternalMemoryHandleTypeFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator~( ExternalMemoryHandleTypeFlagBits bits )
-  {
-    return ~( ExternalMemoryHandleTypeFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBits::eD3D12Resource) | VkFlags(ExternalMemoryHandleTypeFlagBits::eDmaBufEXT) | VkFlags(ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID) | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT) | VkFlags(ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT)
-    };
-  };
-
-  using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags;
-
-  struct PhysicalDeviceExternalImageFormatInfo
-  {
-    PhysicalDeviceExternalImageFormatInfo( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
-      : handleType( handleType_ )
-    {
-    }
-
-    PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) );
-    }
-
-    PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) );
-      return *this;
-    }
-    PhysicalDeviceExternalImageFormatInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalImageFormatInfo& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceExternalImageFormatInfo const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(this);
-    }
-
-    operator VkPhysicalDeviceExternalImageFormatInfo &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(this);
-    }
-
-    bool operator==( PhysicalDeviceExternalImageFormatInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( PhysicalDeviceExternalImageFormatInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagBits handleType;
-  };
-  static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "struct and wrapper have different size!" );
-
-  using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
-
-  struct PhysicalDeviceExternalBufferInfo
-  {
-    PhysicalDeviceExternalBufferInfo( BufferCreateFlags flags_ = BufferCreateFlags(),
-                                      BufferUsageFlags usage_ = BufferUsageFlags(),
-                                      ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
-      : flags( flags_ )
-      , usage( usage_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) );
-    }
-
-    PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) );
-      return *this;
-    }
-    PhysicalDeviceExternalBufferInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalBufferInfo& setFlags( BufferCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalBufferInfo& setUsage( BufferUsageFlags usage_ )
-    {
-      usage = usage_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalBufferInfo& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceExternalBufferInfo const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>(this);
-    }
-
-    operator VkPhysicalDeviceExternalBufferInfo &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>(this);
-    }
-
-    bool operator==( PhysicalDeviceExternalBufferInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( usage == rhs.usage )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( PhysicalDeviceExternalBufferInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo;
-
-  public:
-    const void* pNext = nullptr;
-    BufferCreateFlags flags;
-    BufferUsageFlags usage;
-    ExternalMemoryHandleTypeFlagBits handleType;
-  };
-  static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "struct and wrapper have different size!" );
-
-  using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
-
-  struct ExternalMemoryImageCreateInfo
-  {
-    ExternalMemoryImageCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) );
-    }
-
-    ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) );
-      return *this;
-    }
-    ExternalMemoryImageCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExternalMemoryImageCreateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator VkExternalMemoryImageCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(this);
-    }
-
-    operator VkExternalMemoryImageCreateInfo &()
-    {
-      return *reinterpret_cast<VkExternalMemoryImageCreateInfo*>(this);
-    }
-
-    bool operator==( ExternalMemoryImageCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExternalMemoryImageCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalMemoryImageCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlags handleTypes;
-  };
-  static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "struct and wrapper have different size!" );
-
-  using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
-
-  struct ExternalMemoryBufferCreateInfo
-  {
-    ExternalMemoryBufferCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) );
-    }
-
-    ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) );
-      return *this;
-    }
-    ExternalMemoryBufferCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExternalMemoryBufferCreateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator VkExternalMemoryBufferCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(this);
-    }
-
-    operator VkExternalMemoryBufferCreateInfo &()
-    {
-      return *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(this);
-    }
-
-    bool operator==( ExternalMemoryBufferCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExternalMemoryBufferCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalMemoryBufferCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlags handleTypes;
-  };
-  static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "struct and wrapper have different size!" );
-
-  using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
-
-  struct ExportMemoryAllocateInfo
-  {
-    ExportMemoryAllocateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) );
-    }
-
-    ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) );
-      return *this;
-    }
-    ExportMemoryAllocateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportMemoryAllocateInfo& setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator VkExportMemoryAllocateInfo const&() const
-    {
-      return *reinterpret_cast<const VkExportMemoryAllocateInfo*>(this);
-    }
-
-    operator VkExportMemoryAllocateInfo &()
-    {
-      return *reinterpret_cast<VkExportMemoryAllocateInfo*>(this);
-    }
-
-    bool operator==( ExportMemoryAllocateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExportMemoryAllocateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportMemoryAllocateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlags handleTypes;
-  };
-  static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "struct and wrapper have different size!" );
-
-  using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ImportMemoryWin32HandleInfoKHR
-  {
-    ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
-                                    HANDLE handle_ = 0,
-                                    LPCWSTR name_ = 0 )
-      : handleType( handleType_ )
-      , handle( handle_ )
-      , name( name_ )
-    {
-    }
-
-    ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
-    }
-
-    ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
-      return *this;
-    }
-    ImportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportMemoryWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportMemoryWin32HandleInfoKHR& setHandle( HANDLE handle_ )
-    {
-      handle = handle_;
-      return *this;
-    }
-
-    ImportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ )
-    {
-      name = name_;
-      return *this;
-    }
-
-    operator VkImportMemoryWin32HandleInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(this);
-    }
-
-    operator VkImportMemoryWin32HandleInfoKHR &()
-    {
-      return *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( ImportMemoryWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType )
-          && ( handle == rhs.handle )
-          && ( name == rhs.name );
-    }
-
-    bool operator!=( ImportMemoryWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagBits handleType;
-    HANDLE handle;
-    LPCWSTR name;
-  };
-  static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct MemoryGetWin32HandleInfoKHR
-  {
-    MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(),
-                                 ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
-      : memory( memory_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
-    }
-
-    MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
-      return *this;
-    }
-    MemoryGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MemoryGetWin32HandleInfoKHR& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    MemoryGetWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator VkMemoryGetWin32HandleInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>(this);
-    }
-
-    operator VkMemoryGetWin32HandleInfoKHR &()
-    {
-      return *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( MemoryGetWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memory == rhs.memory )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( MemoryGetWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceMemory memory;
-    ExternalMemoryHandleTypeFlagBits handleType;
-  };
-  static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct ImportMemoryFdInfoKHR
-  {
-    ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
-                           int fd_ = 0 )
-      : handleType( handleType_ )
-      , fd( fd_ )
-    {
-    }
-
-    ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
-    }
-
-    ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
-      return *this;
-    }
-    ImportMemoryFdInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportMemoryFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportMemoryFdInfoKHR& setFd( int fd_ )
-    {
-      fd = fd_;
-      return *this;
-    }
-
-    operator VkImportMemoryFdInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkImportMemoryFdInfoKHR*>(this);
-    }
-
-    operator VkImportMemoryFdInfoKHR &()
-    {
-      return *reinterpret_cast<VkImportMemoryFdInfoKHR*>(this);
-    }
-
-    bool operator==( ImportMemoryFdInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType )
-          && ( fd == rhs.fd );
-    }
-
-    bool operator!=( ImportMemoryFdInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportMemoryFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagBits handleType;
-    int fd;
-  };
-  static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" );
-
-  struct MemoryGetFdInfoKHR
-  {
-    MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(),
-                        ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
-      : memory( memory_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
-    }
-
-    MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
-      return *this;
-    }
-    MemoryGetFdInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MemoryGetFdInfoKHR& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    MemoryGetFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator VkMemoryGetFdInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkMemoryGetFdInfoKHR*>(this);
-    }
-
-    operator VkMemoryGetFdInfoKHR &()
-    {
-      return *reinterpret_cast<VkMemoryGetFdInfoKHR*>(this);
-    }
-
-    bool operator==( MemoryGetFdInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memory == rhs.memory )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( MemoryGetFdInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryGetFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceMemory memory;
-    ExternalMemoryHandleTypeFlagBits handleType;
-  };
-  static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" );
-
-  struct ImportMemoryHostPointerInfoEXT
-  {
-    ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
-                                    void* pHostPointer_ = nullptr )
-      : handleType( handleType_ )
-      , pHostPointer( pHostPointer_ )
-    {
-    }
-
-    ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
-    }
-
-    ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
-      return *this;
-    }
-    ImportMemoryHostPointerInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportMemoryHostPointerInfoEXT& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportMemoryHostPointerInfoEXT& setPHostPointer( void* pHostPointer_ )
-    {
-      pHostPointer = pHostPointer_;
-      return *this;
-    }
-
-    operator VkImportMemoryHostPointerInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(this);
-    }
-
-    operator VkImportMemoryHostPointerInfoEXT &()
-    {
-      return *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(this);
-    }
-
-    bool operator==( ImportMemoryHostPointerInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType )
-          && ( pHostPointer == rhs.pHostPointer );
-    }
-
-    bool operator!=( ImportMemoryHostPointerInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagBits handleType;
-    void* pHostPointer;
-  };
-  static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class ExternalMemoryFeatureFlagBits
-  {
-    eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
-    eDedicatedOnlyKHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
-    eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
-    eExportableKHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
-    eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
-    eImportableKHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT
-  };
-
-  using ExternalMemoryFeatureFlags = Flags<ExternalMemoryFeatureFlagBits, VkExternalMemoryFeatureFlags>;
-
-  VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator|( ExternalMemoryFeatureFlagBits bit0, ExternalMemoryFeatureFlagBits bit1 )
-  {
-    return ExternalMemoryFeatureFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator~( ExternalMemoryFeatureFlagBits bits )
-  {
-    return ~( ExternalMemoryFeatureFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalMemoryFeatureFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalMemoryFeatureFlagBits::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBits::eExportable) | VkFlags(ExternalMemoryFeatureFlagBits::eImportable)
-    };
-  };
-
-  using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags;
-
-  struct ExternalMemoryProperties
-  {
-    operator VkExternalMemoryProperties const&() const
-    {
-      return *reinterpret_cast<const VkExternalMemoryProperties*>(this);
-    }
-
-    operator VkExternalMemoryProperties &()
-    {
-      return *reinterpret_cast<VkExternalMemoryProperties*>(this);
-    }
-
-    bool operator==( ExternalMemoryProperties const& rhs ) const
-    {
-      return ( externalMemoryFeatures == rhs.externalMemoryFeatures )
-          && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
-          && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
-    }
-
-    bool operator!=( ExternalMemoryProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ExternalMemoryFeatureFlags externalMemoryFeatures;
-    ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;
-    ExternalMemoryHandleTypeFlags compatibleHandleTypes;
-  };
-  static_assert( sizeof( ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), "struct and wrapper have different size!" );
-
-  using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
-
-  struct ExternalImageFormatProperties
-  {
-    operator VkExternalImageFormatProperties const&() const
-    {
-      return *reinterpret_cast<const VkExternalImageFormatProperties*>(this);
-    }
-
-    operator VkExternalImageFormatProperties &()
-    {
-      return *reinterpret_cast<VkExternalImageFormatProperties*>(this);
-    }
-
-    bool operator==( ExternalImageFormatProperties const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( externalMemoryProperties == rhs.externalMemoryProperties );
-    }
-
-    bool operator!=( ExternalImageFormatProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalImageFormatProperties;
-
-  public:
-    void* pNext = nullptr;
-    ExternalMemoryProperties externalMemoryProperties;
-  };
-  static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "struct and wrapper have different size!" );
-
-  using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
-
-  struct ExternalBufferProperties
-  {
-    operator VkExternalBufferProperties const&() const
-    {
-      return *reinterpret_cast<const VkExternalBufferProperties*>(this);
-    }
-
-    operator VkExternalBufferProperties &()
-    {
-      return *reinterpret_cast<VkExternalBufferProperties*>(this);
-    }
-
-    bool operator==( ExternalBufferProperties const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( externalMemoryProperties == rhs.externalMemoryProperties );
-    }
-
-    bool operator!=( ExternalBufferProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalBufferProperties;
-
-  public:
-    void* pNext = nullptr;
-    ExternalMemoryProperties externalMemoryProperties;
-  };
-  static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "struct and wrapper have different size!" );
-
-  using ExternalBufferPropertiesKHR = ExternalBufferProperties;
-
-  enum class ExternalSemaphoreHandleTypeFlagBits
-  {
-    eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
-    eOpaqueFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
-    eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
-    eOpaqueWin32KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
-    eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
-    eOpaqueWin32KmtKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
-    eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
-    eD3D12FenceKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
-    eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
-    eSyncFdKHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
-  };
-
-  using ExternalSemaphoreHandleTypeFlags = Flags<ExternalSemaphoreHandleTypeFlagBits, VkExternalSemaphoreHandleTypeFlags>;
-
-  VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator|( ExternalSemaphoreHandleTypeFlagBits bit0, ExternalSemaphoreHandleTypeFlagBits bit1 )
-  {
-    return ExternalSemaphoreHandleTypeFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator~( ExternalSemaphoreHandleTypeFlagBits bits )
-  {
-    return ~( ExternalSemaphoreHandleTypeFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalSemaphoreHandleTypeFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence) | VkFlags(ExternalSemaphoreHandleTypeFlagBits::eSyncFd)
-    };
-  };
-
-  using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags;
-
-  struct PhysicalDeviceExternalSemaphoreInfo
-  {
-    PhysicalDeviceExternalSemaphoreInfo( ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
-      : handleType( handleType_ )
-    {
-    }
-
-    PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) );
-    }
-
-    PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) );
-      return *this;
-    }
-    PhysicalDeviceExternalSemaphoreInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalSemaphoreInfo& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceExternalSemaphoreInfo const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>(this);
-    }
-
-    operator VkPhysicalDeviceExternalSemaphoreInfo &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(this);
-    }
-
-    bool operator==( PhysicalDeviceExternalSemaphoreInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( PhysicalDeviceExternalSemaphoreInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalSemaphoreHandleTypeFlagBits handleType;
-  };
-  static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "struct and wrapper have different size!" );
-
-  using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
-
-  struct ExportSemaphoreCreateInfo
-  {
-    ExportSemaphoreCreateInfo( ExternalSemaphoreHandleTypeFlags handleTypes_ = ExternalSemaphoreHandleTypeFlags() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) );
-    }
-
-    ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) );
-      return *this;
-    }
-    ExportSemaphoreCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportSemaphoreCreateInfo& setHandleTypes( ExternalSemaphoreHandleTypeFlags handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator VkExportSemaphoreCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkExportSemaphoreCreateInfo*>(this);
-    }
-
-    operator VkExportSemaphoreCreateInfo &()
-    {
-      return *reinterpret_cast<VkExportSemaphoreCreateInfo*>(this);
-    }
-
-    bool operator==( ExportSemaphoreCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExportSemaphoreCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportSemaphoreCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalSemaphoreHandleTypeFlags handleTypes;
-  };
-  static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "struct and wrapper have different size!" );
-
-  using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct SemaphoreGetWin32HandleInfoKHR
-  {
-    SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
-                                    ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
-      : semaphore( semaphore_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
-    }
-
-    SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
-      return *this;
-    }
-    SemaphoreGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SemaphoreGetWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ )
-    {
-      semaphore = semaphore_;
-      return *this;
-    }
-
-    SemaphoreGetWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator VkSemaphoreGetWin32HandleInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>(this);
-    }
-
-    operator VkSemaphoreGetWin32HandleInfoKHR &()
-    {
-      return *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( SemaphoreGetWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( semaphore == rhs.semaphore )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( SemaphoreGetWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Semaphore semaphore;
-    ExternalSemaphoreHandleTypeFlagBits handleType;
-  };
-  static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct SemaphoreGetFdInfoKHR
-  {
-    SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(),
-                           ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
-      : semaphore( semaphore_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
-    }
-
-    SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
-      return *this;
-    }
-    SemaphoreGetFdInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SemaphoreGetFdInfoKHR& setSemaphore( Semaphore semaphore_ )
-    {
-      semaphore = semaphore_;
-      return *this;
-    }
-
-    SemaphoreGetFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator VkSemaphoreGetFdInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>(this);
-    }
-
-    operator VkSemaphoreGetFdInfoKHR &()
-    {
-      return *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(this);
-    }
-
-    bool operator==( SemaphoreGetFdInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( semaphore == rhs.semaphore )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( SemaphoreGetFdInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSemaphoreGetFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Semaphore semaphore;
-    ExternalSemaphoreHandleTypeFlagBits handleType;
-  };
-  static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class ExternalSemaphoreFeatureFlagBits
-  {
-    eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
-    eExportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
-    eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT,
-    eImportableKHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT
-  };
-
-  using ExternalSemaphoreFeatureFlags = Flags<ExternalSemaphoreFeatureFlagBits, VkExternalSemaphoreFeatureFlags>;
-
-  VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator|( ExternalSemaphoreFeatureFlagBits bit0, ExternalSemaphoreFeatureFlagBits bit1 )
-  {
-    return ExternalSemaphoreFeatureFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator~( ExternalSemaphoreFeatureFlagBits bits )
-  {
-    return ~( ExternalSemaphoreFeatureFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalSemaphoreFeatureFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalSemaphoreFeatureFlagBits::eExportable) | VkFlags(ExternalSemaphoreFeatureFlagBits::eImportable)
-    };
-  };
-
-  using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags;
-
-  struct ExternalSemaphoreProperties
-  {
-    operator VkExternalSemaphoreProperties const&() const
-    {
-      return *reinterpret_cast<const VkExternalSemaphoreProperties*>(this);
-    }
-
-    operator VkExternalSemaphoreProperties &()
-    {
-      return *reinterpret_cast<VkExternalSemaphoreProperties*>(this);
-    }
-
-    bool operator==( ExternalSemaphoreProperties const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
-          && ( compatibleHandleTypes == rhs.compatibleHandleTypes )
-          && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures );
-    }
-
-    bool operator!=( ExternalSemaphoreProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalSemaphoreProperties;
-
-  public:
-    void* pNext = nullptr;
-    ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
-    ExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
-    ExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
-  };
-  static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "struct and wrapper have different size!" );
-
-  using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
-
-  enum class SemaphoreImportFlagBits
-  {
-    eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
-    eTemporaryKHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT
-  };
-
-  using SemaphoreImportFlags = Flags<SemaphoreImportFlagBits, VkSemaphoreImportFlags>;
-
-  VULKAN_HPP_INLINE SemaphoreImportFlags operator|( SemaphoreImportFlagBits bit0, SemaphoreImportFlagBits bit1 )
-  {
-    return SemaphoreImportFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SemaphoreImportFlags operator~( SemaphoreImportFlagBits bits )
-  {
-    return ~( SemaphoreImportFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<SemaphoreImportFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(SemaphoreImportFlagBits::eTemporary)
-    };
-  };
-
-  using SemaphoreImportFlagsKHR = SemaphoreImportFlags;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ImportSemaphoreWin32HandleInfoKHR
-  {
-    ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
-                                       SemaphoreImportFlags flags_ = SemaphoreImportFlags(),
-                                       ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
-                                       HANDLE handle_ = 0,
-                                       LPCWSTR name_ = 0 )
-      : semaphore( semaphore_ )
-      , flags( flags_ )
-      , handleType( handleType_ )
-      , handle( handle_ )
-      , name( name_ )
-    {
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
-      return *this;
-    }
-    ImportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ )
-    {
-      semaphore = semaphore_;
-      return *this;
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR& setFlags( SemaphoreImportFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR& setHandle( HANDLE handle_ )
-    {
-      handle = handle_;
-      return *this;
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ )
-    {
-      name = name_;
-      return *this;
-    }
-
-    operator VkImportSemaphoreWin32HandleInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>(this);
-    }
-
-    operator VkImportSemaphoreWin32HandleInfoKHR &()
-    {
-      return *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( semaphore == rhs.semaphore )
-          && ( flags == rhs.flags )
-          && ( handleType == rhs.handleType )
-          && ( handle == rhs.handle )
-          && ( name == rhs.name );
-    }
-
-    bool operator!=( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Semaphore semaphore;
-    SemaphoreImportFlags flags;
-    ExternalSemaphoreHandleTypeFlagBits handleType;
-    HANDLE handle;
-    LPCWSTR name;
-  };
-  static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct ImportSemaphoreFdInfoKHR
-  {
-    ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(),
-                              SemaphoreImportFlags flags_ = SemaphoreImportFlags(),
-                              ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
-                              int fd_ = 0 )
-      : semaphore( semaphore_ )
-      , flags( flags_ )
-      , handleType( handleType_ )
-      , fd( fd_ )
-    {
-    }
-
-    ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
-    }
-
-    ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
-      return *this;
-    }
-    ImportSemaphoreFdInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportSemaphoreFdInfoKHR& setSemaphore( Semaphore semaphore_ )
-    {
-      semaphore = semaphore_;
-      return *this;
-    }
-
-    ImportSemaphoreFdInfoKHR& setFlags( SemaphoreImportFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ImportSemaphoreFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportSemaphoreFdInfoKHR& setFd( int fd_ )
-    {
-      fd = fd_;
-      return *this;
-    }
-
-    operator VkImportSemaphoreFdInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>(this);
-    }
-
-    operator VkImportSemaphoreFdInfoKHR &()
-    {
-      return *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>(this);
-    }
-
-    bool operator==( ImportSemaphoreFdInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( semaphore == rhs.semaphore )
-          && ( flags == rhs.flags )
-          && ( handleType == rhs.handleType )
-          && ( fd == rhs.fd );
-    }
-
-    bool operator!=( ImportSemaphoreFdInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportSemaphoreFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Semaphore semaphore;
-    SemaphoreImportFlags flags;
-    ExternalSemaphoreHandleTypeFlagBits handleType;
-    int fd;
-  };
-  static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class ExternalFenceHandleTypeFlagBits
-  {
-    eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
-    eOpaqueFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
-    eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
-    eOpaqueWin32KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
-    eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
-    eOpaqueWin32KmtKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
-    eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
-    eSyncFdKHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
-  };
-
-  using ExternalFenceHandleTypeFlags = Flags<ExternalFenceHandleTypeFlagBits, VkExternalFenceHandleTypeFlags>;
-
-  VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator|( ExternalFenceHandleTypeFlagBits bit0, ExternalFenceHandleTypeFlagBits bit1 )
-  {
-    return ExternalFenceHandleTypeFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator~( ExternalFenceHandleTypeFlagBits bits )
-  {
-    return ~( ExternalFenceHandleTypeFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalFenceHandleTypeFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueFd) | VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32) | VkFlags(ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt) | VkFlags(ExternalFenceHandleTypeFlagBits::eSyncFd)
-    };
-  };
-
-  using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags;
-
-  struct PhysicalDeviceExternalFenceInfo
-  {
-    PhysicalDeviceExternalFenceInfo( ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
-      : handleType( handleType_ )
-    {
-    }
-
-    PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) );
-    }
-
-    PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) );
-      return *this;
-    }
-    PhysicalDeviceExternalFenceInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalFenceInfo& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator VkPhysicalDeviceExternalFenceInfo const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>(this);
-    }
-
-    operator VkPhysicalDeviceExternalFenceInfo &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>(this);
-    }
-
-    bool operator==( PhysicalDeviceExternalFenceInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( PhysicalDeviceExternalFenceInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalFenceHandleTypeFlagBits handleType;
-  };
-  static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "struct and wrapper have different size!" );
-
-  using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
-
-  struct ExportFenceCreateInfo
-  {
-    ExportFenceCreateInfo( ExternalFenceHandleTypeFlags handleTypes_ = ExternalFenceHandleTypeFlags() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) );
-    }
-
-    ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) );
-      return *this;
-    }
-    ExportFenceCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportFenceCreateInfo& setHandleTypes( ExternalFenceHandleTypeFlags handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator VkExportFenceCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkExportFenceCreateInfo*>(this);
-    }
-
-    operator VkExportFenceCreateInfo &()
-    {
-      return *reinterpret_cast<VkExportFenceCreateInfo*>(this);
-    }
-
-    bool operator==( ExportFenceCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExportFenceCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportFenceCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalFenceHandleTypeFlags handleTypes;
-  };
-  static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "struct and wrapper have different size!" );
-
-  using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct FenceGetWin32HandleInfoKHR
-  {
-    FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(),
-                                ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
-      : fence( fence_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
-    }
-
-    FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
-      return *this;
-    }
-    FenceGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    FenceGetWin32HandleInfoKHR& setFence( Fence fence_ )
-    {
-      fence = fence_;
-      return *this;
-    }
-
-    FenceGetWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator VkFenceGetWin32HandleInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>(this);
-    }
-
-    operator VkFenceGetWin32HandleInfoKHR &()
-    {
-      return *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( FenceGetWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( fence == rhs.fence )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( FenceGetWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Fence fence;
-    ExternalFenceHandleTypeFlagBits handleType;
-  };
-  static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct FenceGetFdInfoKHR
-  {
-    FenceGetFdInfoKHR( Fence fence_ = Fence(),
-                       ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
-      : fence( fence_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
-    }
-
-    FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
-      return *this;
-    }
-    FenceGetFdInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    FenceGetFdInfoKHR& setFence( Fence fence_ )
-    {
-      fence = fence_;
-      return *this;
-    }
-
-    FenceGetFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator VkFenceGetFdInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkFenceGetFdInfoKHR*>(this);
-    }
-
-    operator VkFenceGetFdInfoKHR &()
-    {
-      return *reinterpret_cast<VkFenceGetFdInfoKHR*>(this);
-    }
-
-    bool operator==( FenceGetFdInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( fence == rhs.fence )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( FenceGetFdInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eFenceGetFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Fence fence;
-    ExternalFenceHandleTypeFlagBits handleType;
-  };
-  static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class ExternalFenceFeatureFlagBits
-  {
-    eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
-    eExportableKHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
-    eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT,
-    eImportableKHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT
-  };
-
-  using ExternalFenceFeatureFlags = Flags<ExternalFenceFeatureFlagBits, VkExternalFenceFeatureFlags>;
-
-  VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator|( ExternalFenceFeatureFlagBits bit0, ExternalFenceFeatureFlagBits bit1 )
-  {
-    return ExternalFenceFeatureFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator~( ExternalFenceFeatureFlagBits bits )
-  {
-    return ~( ExternalFenceFeatureFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalFenceFeatureFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalFenceFeatureFlagBits::eExportable) | VkFlags(ExternalFenceFeatureFlagBits::eImportable)
-    };
-  };
-
-  using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags;
-
-  struct ExternalFenceProperties
-  {
-    operator VkExternalFenceProperties const&() const
-    {
-      return *reinterpret_cast<const VkExternalFenceProperties*>(this);
-    }
-
-    operator VkExternalFenceProperties &()
-    {
-      return *reinterpret_cast<VkExternalFenceProperties*>(this);
-    }
-
-    bool operator==( ExternalFenceProperties const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
-          && ( compatibleHandleTypes == rhs.compatibleHandleTypes )
-          && ( externalFenceFeatures == rhs.externalFenceFeatures );
-    }
-
-    bool operator!=( ExternalFenceProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalFenceProperties;
-
-  public:
-    void* pNext = nullptr;
-    ExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
-    ExternalFenceHandleTypeFlags compatibleHandleTypes;
-    ExternalFenceFeatureFlags externalFenceFeatures;
-  };
-  static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "struct and wrapper have different size!" );
-
-  using ExternalFencePropertiesKHR = ExternalFenceProperties;
-
-  enum class FenceImportFlagBits
-  {
-    eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT,
-    eTemporaryKHR = VK_FENCE_IMPORT_TEMPORARY_BIT
-  };
-
-  using FenceImportFlags = Flags<FenceImportFlagBits, VkFenceImportFlags>;
-
-  VULKAN_HPP_INLINE FenceImportFlags operator|( FenceImportFlagBits bit0, FenceImportFlagBits bit1 )
-  {
-    return FenceImportFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE FenceImportFlags operator~( FenceImportFlagBits bits )
-  {
-    return ~( FenceImportFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<FenceImportFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(FenceImportFlagBits::eTemporary)
-    };
-  };
-
-  using FenceImportFlagsKHR = FenceImportFlags;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ImportFenceWin32HandleInfoKHR
-  {
-    ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(),
-                                   FenceImportFlags flags_ = FenceImportFlags(),
-                                   ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd,
-                                   HANDLE handle_ = 0,
-                                   LPCWSTR name_ = 0 )
-      : fence( fence_ )
-      , flags( flags_ )
-      , handleType( handleType_ )
-      , handle( handle_ )
-      , name( name_ )
-    {
-    }
-
-    ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
-    }
-
-    ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
-      return *this;
-    }
-    ImportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportFenceWin32HandleInfoKHR& setFence( Fence fence_ )
-    {
-      fence = fence_;
-      return *this;
-    }
-
-    ImportFenceWin32HandleInfoKHR& setFlags( FenceImportFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ImportFenceWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportFenceWin32HandleInfoKHR& setHandle( HANDLE handle_ )
-    {
-      handle = handle_;
-      return *this;
-    }
-
-    ImportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ )
-    {
-      name = name_;
-      return *this;
-    }
-
-    operator VkImportFenceWin32HandleInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>(this);
-    }
-
-    operator VkImportFenceWin32HandleInfoKHR &()
-    {
-      return *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( ImportFenceWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( fence == rhs.fence )
-          && ( flags == rhs.flags )
-          && ( handleType == rhs.handleType )
-          && ( handle == rhs.handle )
-          && ( name == rhs.name );
-    }
-
-    bool operator!=( ImportFenceWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Fence fence;
-    FenceImportFlags flags;
-    ExternalFenceHandleTypeFlagBits handleType;
-    HANDLE handle;
-    LPCWSTR name;
-  };
-  static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct ImportFenceFdInfoKHR
-  {
-    ImportFenceFdInfoKHR( Fence fence_ = Fence(),
-                          FenceImportFlags flags_ = FenceImportFlags(),
-                          ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd,
-                          int fd_ = 0 )
-      : fence( fence_ )
-      , flags( flags_ )
-      , handleType( handleType_ )
-      , fd( fd_ )
-    {
-    }
-
-    ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
-    }
-
-    ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
-      return *this;
-    }
-    ImportFenceFdInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportFenceFdInfoKHR& setFence( Fence fence_ )
-    {
-      fence = fence_;
-      return *this;
-    }
-
-    ImportFenceFdInfoKHR& setFlags( FenceImportFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ImportFenceFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportFenceFdInfoKHR& setFd( int fd_ )
-    {
-      fd = fd_;
-      return *this;
-    }
-
-    operator VkImportFenceFdInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkImportFenceFdInfoKHR*>(this);
-    }
-
-    operator VkImportFenceFdInfoKHR &()
-    {
-      return *reinterpret_cast<VkImportFenceFdInfoKHR*>(this);
-    }
-
-    bool operator==( ImportFenceFdInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( fence == rhs.fence )
-          && ( flags == rhs.flags )
-          && ( handleType == rhs.handleType )
-          && ( fd == rhs.fd );
-    }
-
-    bool operator!=( ImportFenceFdInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportFenceFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Fence fence;
-    FenceImportFlags flags;
-    ExternalFenceHandleTypeFlagBits handleType;
-    int fd;
-  };
-  static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class SurfaceCounterFlagBitsEXT
-  {
-    eVblank = VK_SURFACE_COUNTER_VBLANK_EXT
-  };
-
-  using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT, VkSurfaceCounterFlagsEXT>;
-
-  VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator|( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 )
-  {
-    return SurfaceCounterFlagsEXT( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator~( SurfaceCounterFlagBitsEXT bits )
-  {
-    return ~( SurfaceCounterFlagsEXT( bits ) );
-  }
-
-  template <> struct FlagTraits<SurfaceCounterFlagBitsEXT>
-  {
-    enum
-    {
-      allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblank)
-    };
-  };
-
-  struct SurfaceCapabilities2EXT
-  {
-    operator VkSurfaceCapabilities2EXT const&() const
-    {
-      return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>(this);
-    }
-
-    operator VkSurfaceCapabilities2EXT &()
-    {
-      return *reinterpret_cast<VkSurfaceCapabilities2EXT*>(this);
-    }
-
-    bool operator==( SurfaceCapabilities2EXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( minImageCount == rhs.minImageCount )
-          && ( maxImageCount == rhs.maxImageCount )
-          && ( currentExtent == rhs.currentExtent )
-          && ( minImageExtent == rhs.minImageExtent )
-          && ( maxImageExtent == rhs.maxImageExtent )
-          && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
-          && ( supportedTransforms == rhs.supportedTransforms )
-          && ( currentTransform == rhs.currentTransform )
-          && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
-          && ( supportedUsageFlags == rhs.supportedUsageFlags )
-          && ( supportedSurfaceCounters == rhs.supportedSurfaceCounters );
-    }
-
-    bool operator!=( SurfaceCapabilities2EXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSurfaceCapabilities2EXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t minImageCount;
-    uint32_t maxImageCount;
-    Extent2D currentExtent;
-    Extent2D minImageExtent;
-    Extent2D maxImageExtent;
-    uint32_t maxImageArrayLayers;
-    SurfaceTransformFlagsKHR supportedTransforms;
-    SurfaceTransformFlagBitsKHR currentTransform;
-    CompositeAlphaFlagsKHR supportedCompositeAlpha;
-    ImageUsageFlags supportedUsageFlags;
-    SurfaceCounterFlagsEXT supportedSurfaceCounters;
-  };
-  static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" );
-
-  struct SwapchainCounterCreateInfoEXT
-  {
-    SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() )
-      : surfaceCounters( surfaceCounters_ )
-    {
-    }
-
-    SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
-    }
-
-    SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
-      return *this;
-    }
-    SwapchainCounterCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SwapchainCounterCreateInfoEXT& setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ )
-    {
-      surfaceCounters = surfaceCounters_;
-      return *this;
-    }
-
-    operator VkSwapchainCounterCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(this);
-    }
-
-    operator VkSwapchainCounterCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(this);
-    }
-
-    bool operator==( SwapchainCounterCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( surfaceCounters == rhs.surfaceCounters );
-    }
-
-    bool operator!=( SwapchainCounterCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    SurfaceCounterFlagsEXT surfaceCounters;
-  };
-  static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class DisplayPowerStateEXT
-  {
-    eOff = VK_DISPLAY_POWER_STATE_OFF_EXT,
-    eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT,
-    eOn = VK_DISPLAY_POWER_STATE_ON_EXT
-  };
-
-  struct DisplayPowerInfoEXT
-  {
-    DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff )
-      : powerState( powerState_ )
-    {
-    }
-
-    DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
-    }
-
-    DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
-      return *this;
-    }
-    DisplayPowerInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DisplayPowerInfoEXT& setPowerState( DisplayPowerStateEXT powerState_ )
-    {
-      powerState = powerState_;
-      return *this;
-    }
-
-    operator VkDisplayPowerInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkDisplayPowerInfoEXT*>(this);
-    }
-
-    operator VkDisplayPowerInfoEXT &()
-    {
-      return *reinterpret_cast<VkDisplayPowerInfoEXT*>(this);
-    }
-
-    bool operator==( DisplayPowerInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( powerState == rhs.powerState );
-    }
-
-    bool operator!=( DisplayPowerInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDisplayPowerInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DisplayPowerStateEXT powerState;
-  };
-  static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class DeviceEventTypeEXT
-  {
-    eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT
-  };
-
-  struct DeviceEventInfoEXT
-  {
-    DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug )
-      : deviceEvent( deviceEvent_ )
-    {
-    }
-
-    DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
-    }
-
-    DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
-      return *this;
-    }
-    DeviceEventInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceEventInfoEXT& setDeviceEvent( DeviceEventTypeEXT deviceEvent_ )
-    {
-      deviceEvent = deviceEvent_;
-      return *this;
-    }
-
-    operator VkDeviceEventInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkDeviceEventInfoEXT*>(this);
-    }
-
-    operator VkDeviceEventInfoEXT &()
-    {
-      return *reinterpret_cast<VkDeviceEventInfoEXT*>(this);
-    }
-
-    bool operator==( DeviceEventInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( deviceEvent == rhs.deviceEvent );
-    }
-
-    bool operator!=( DeviceEventInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceEventInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceEventTypeEXT deviceEvent;
-  };
-  static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class DisplayEventTypeEXT
-  {
-    eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT
-  };
-
-  struct DisplayEventInfoEXT
-  {
-    DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut )
-      : displayEvent( displayEvent_ )
-    {
-    }
-
-    DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
-    }
-
-    DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
-      return *this;
-    }
-    DisplayEventInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DisplayEventInfoEXT& setDisplayEvent( DisplayEventTypeEXT displayEvent_ )
-    {
-      displayEvent = displayEvent_;
-      return *this;
-    }
-
-    operator VkDisplayEventInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkDisplayEventInfoEXT*>(this);
-    }
-
-    operator VkDisplayEventInfoEXT &()
-    {
-      return *reinterpret_cast<VkDisplayEventInfoEXT*>(this);
-    }
-
-    bool operator==( DisplayEventInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( displayEvent == rhs.displayEvent );
-    }
-
-    bool operator!=( DisplayEventInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDisplayEventInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DisplayEventTypeEXT displayEvent;
-  };
-  static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class PeerMemoryFeatureFlagBits
-  {
-    eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
-    eCopySrcKHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
-    eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
-    eCopyDstKHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
-    eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
-    eGenericSrcKHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
-    eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT,
-    eGenericDstKHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT
-  };
-
-  using PeerMemoryFeatureFlags = Flags<PeerMemoryFeatureFlagBits, VkPeerMemoryFeatureFlags>;
-
-  VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator|( PeerMemoryFeatureFlagBits bit0, PeerMemoryFeatureFlagBits bit1 )
-  {
-    return PeerMemoryFeatureFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator~( PeerMemoryFeatureFlagBits bits )
-  {
-    return ~( PeerMemoryFeatureFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<PeerMemoryFeatureFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(PeerMemoryFeatureFlagBits::eCopySrc) | VkFlags(PeerMemoryFeatureFlagBits::eCopyDst) | VkFlags(PeerMemoryFeatureFlagBits::eGenericSrc) | VkFlags(PeerMemoryFeatureFlagBits::eGenericDst)
-    };
-  };
-
-  using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags;
-
-  enum class MemoryAllocateFlagBits
-  {
-    eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
-    eDeviceMaskKHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT
-  };
-
-  using MemoryAllocateFlags = Flags<MemoryAllocateFlagBits, VkMemoryAllocateFlags>;
-
-  VULKAN_HPP_INLINE MemoryAllocateFlags operator|( MemoryAllocateFlagBits bit0, MemoryAllocateFlagBits bit1 )
-  {
-    return MemoryAllocateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE MemoryAllocateFlags operator~( MemoryAllocateFlagBits bits )
-  {
-    return ~( MemoryAllocateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<MemoryAllocateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(MemoryAllocateFlagBits::eDeviceMask)
-    };
-  };
-
-  using MemoryAllocateFlagsKHR = MemoryAllocateFlags;
-
-  struct MemoryAllocateFlagsInfo
-  {
-    MemoryAllocateFlagsInfo( MemoryAllocateFlags flags_ = MemoryAllocateFlags(),
-                             uint32_t deviceMask_ = 0 )
-      : flags( flags_ )
-      , deviceMask( deviceMask_ )
-    {
-    }
-
-    MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) );
-    }
-
-    MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) );
-      return *this;
-    }
-    MemoryAllocateFlagsInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MemoryAllocateFlagsInfo& setFlags( MemoryAllocateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    MemoryAllocateFlagsInfo& setDeviceMask( uint32_t deviceMask_ )
-    {
-      deviceMask = deviceMask_;
-      return *this;
-    }
-
-    operator VkMemoryAllocateFlagsInfo const&() const
-    {
-      return *reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(this);
-    }
-
-    operator VkMemoryAllocateFlagsInfo &()
-    {
-      return *reinterpret_cast<VkMemoryAllocateFlagsInfo*>(this);
-    }
-
-    bool operator==( MemoryAllocateFlagsInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( deviceMask == rhs.deviceMask );
-    }
-
-    bool operator!=( MemoryAllocateFlagsInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryAllocateFlagsInfo;
-
-  public:
-    const void* pNext = nullptr;
-    MemoryAllocateFlags flags;
-    uint32_t deviceMask;
-  };
-  static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "struct and wrapper have different size!" );
-
-  using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
-
-  enum class DeviceGroupPresentModeFlagBitsKHR
-  {
-    eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR,
-    eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR,
-    eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR,
-    eLocalMultiDevice = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR
-  };
-
-  using DeviceGroupPresentModeFlagsKHR = Flags<DeviceGroupPresentModeFlagBitsKHR, VkDeviceGroupPresentModeFlagsKHR>;
-
-  VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator|( DeviceGroupPresentModeFlagBitsKHR bit0, DeviceGroupPresentModeFlagBitsKHR bit1 )
-  {
-    return DeviceGroupPresentModeFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator~( DeviceGroupPresentModeFlagBitsKHR bits )
-  {
-    return ~( DeviceGroupPresentModeFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<DeviceGroupPresentModeFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocal) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eRemote) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eSum) | VkFlags(DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice)
-    };
-  };
-
-  struct DeviceGroupPresentCapabilitiesKHR
-  {
-    operator VkDeviceGroupPresentCapabilitiesKHR const&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR*>(this);
-    }
-
-    operator VkDeviceGroupPresentCapabilitiesKHR &()
-    {
-      return *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(this);
-    }
-
-    bool operator==( DeviceGroupPresentCapabilitiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memcmp( presentMask, rhs.presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof( uint32_t ) ) == 0 )
-          && ( modes == rhs.modes );
-    }
-
-    bool operator!=( DeviceGroupPresentCapabilitiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
-    DeviceGroupPresentModeFlagsKHR modes;
-  };
-  static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "struct and wrapper have different size!" );
-
-  struct DeviceGroupPresentInfoKHR
-  {
-    DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0,
-                               const uint32_t* pDeviceMasks_ = nullptr,
-                               DeviceGroupPresentModeFlagBitsKHR mode_ = DeviceGroupPresentModeFlagBitsKHR::eLocal )
-      : swapchainCount( swapchainCount_ )
-      , pDeviceMasks( pDeviceMasks_ )
-      , mode( mode_ )
-    {
-    }
-
-    DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) );
-    }
-
-    DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) );
-      return *this;
-    }
-    DeviceGroupPresentInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupPresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ )
-    {
-      swapchainCount = swapchainCount_;
-      return *this;
-    }
-
-    DeviceGroupPresentInfoKHR& setPDeviceMasks( const uint32_t* pDeviceMasks_ )
-    {
-      pDeviceMasks = pDeviceMasks_;
-      return *this;
-    }
-
-    DeviceGroupPresentInfoKHR& setMode( DeviceGroupPresentModeFlagBitsKHR mode_ )
-    {
-      mode = mode_;
-      return *this;
-    }
-
-    operator VkDeviceGroupPresentInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(this);
-    }
-
-    operator VkDeviceGroupPresentInfoKHR &()
-    {
-      return *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(this);
-    }
-
-    bool operator==( DeviceGroupPresentInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( swapchainCount == rhs.swapchainCount )
-          && ( pDeviceMasks == rhs.pDeviceMasks )
-          && ( mode == rhs.mode );
-    }
-
-    bool operator!=( DeviceGroupPresentInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupPresentInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t swapchainCount;
-    const uint32_t* pDeviceMasks;
-    DeviceGroupPresentModeFlagBitsKHR mode;
-  };
-  static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "struct and wrapper have different size!" );
-
-  struct DeviceGroupSwapchainCreateInfoKHR
-  {
-    DeviceGroupSwapchainCreateInfoKHR( DeviceGroupPresentModeFlagsKHR modes_ = DeviceGroupPresentModeFlagsKHR() )
-      : modes( modes_ )
-    {
-    }
-
-    DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) );
-    }
-
-    DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) );
-      return *this;
-    }
-    DeviceGroupSwapchainCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupSwapchainCreateInfoKHR& setModes( DeviceGroupPresentModeFlagsKHR modes_ )
-    {
-      modes = modes_;
-      return *this;
-    }
-
-    operator VkDeviceGroupSwapchainCreateInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(this);
-    }
-
-    operator VkDeviceGroupSwapchainCreateInfoKHR &()
-    {
-      return *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(this);
-    }
-
-    bool operator==( DeviceGroupSwapchainCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( modes == rhs.modes );
-    }
-
-    bool operator!=( DeviceGroupSwapchainCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceGroupPresentModeFlagsKHR modes;
-  };
-  static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class SwapchainCreateFlagBitsKHR
-  {
-    eSplitInstanceBindRegions = VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR,
-    eProtected = VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR,
-    eMutableFormat = VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR
-  };
-
-  using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR, VkSwapchainCreateFlagsKHR>;
-
-  VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator|( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
-  {
-    return SwapchainCreateFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator~( SwapchainCreateFlagBitsKHR bits )
-  {
-    return ~( SwapchainCreateFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<SwapchainCreateFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) | VkFlags(SwapchainCreateFlagBitsKHR::eProtected) | VkFlags(SwapchainCreateFlagBitsKHR::eMutableFormat)
-    };
-  };
-
-  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() )
-      : flags( flags_ )
-      , surface( surface_ )
-      , minImageCount( minImageCount_ )
-      , imageFormat( imageFormat_ )
-      , imageColorSpace( imageColorSpace_ )
-      , imageExtent( imageExtent_ )
-      , imageArrayLayers( imageArrayLayers_ )
-      , imageUsage( imageUsage_ )
-      , imageSharingMode( imageSharingMode_ )
-      , queueFamilyIndexCount( queueFamilyIndexCount_ )
-      , pQueueFamilyIndices( pQueueFamilyIndices_ )
-      , preTransform( preTransform_ )
-      , compositeAlpha( compositeAlpha_ )
-      , presentMode( presentMode_ )
-      , clipped( clipped_ )
-      , oldSwapchain( oldSwapchain_ )
-    {
-    }
-
-    SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
-    }
-
-    SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
-      return *this;
-    }
-    SwapchainCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setFlags( SwapchainCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setSurface( SurfaceKHR surface_ )
+    PhysicalDeviceSurfaceInfo2KHR & setSurface( SurfaceKHR surface_ )
     {
       surface = surface_;
       return *this;
     }
 
-    SwapchainCreateInfoKHR& setMinImageCount( uint32_t minImageCount_ )
+    operator VkPhysicalDeviceSurfaceInfo2KHR const&() const
     {
-      minImageCount = minImageCount_;
-      return *this;
+      return *reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( this );
     }
 
-    SwapchainCreateInfoKHR& setImageFormat( Format imageFormat_ )
+    operator VkPhysicalDeviceSurfaceInfo2KHR &()
     {
-      imageFormat = imageFormat_;
-      return *this;
+      return *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>( this );
     }
 
-    SwapchainCreateInfoKHR& setImageColorSpace( ColorSpaceKHR imageColorSpace_ )
-    {
-      imageColorSpace = imageColorSpace_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
-    {
-      imageExtent = imageExtent_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setImageArrayLayers( uint32_t imageArrayLayers_ )
-    {
-      imageArrayLayers = imageArrayLayers_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setImageUsage( ImageUsageFlags imageUsage_ )
-    {
-      imageUsage = imageUsage_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setImageSharingMode( SharingMode imageSharingMode_ )
-    {
-      imageSharingMode = imageSharingMode_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
-    {
-      queueFamilyIndexCount = queueFamilyIndexCount_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
-    {
-      pQueueFamilyIndices = pQueueFamilyIndices_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ )
-    {
-      preTransform = preTransform_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ )
-    {
-      compositeAlpha = compositeAlpha_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setPresentMode( PresentModeKHR presentMode_ )
-    {
-      presentMode = presentMode_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setClipped( Bool32 clipped_ )
-    {
-      clipped = clipped_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setOldSwapchain( SwapchainKHR oldSwapchain_ )
-    {
-      oldSwapchain = oldSwapchain_;
-      return *this;
-    }
-
-    operator VkSwapchainCreateInfoKHR const&() const
-    {
-      return *reinterpret_cast<const VkSwapchainCreateInfoKHR*>(this);
-    }
-
-    operator VkSwapchainCreateInfoKHR &()
-    {
-      return *reinterpret_cast<VkSwapchainCreateInfoKHR*>(this);
-    }
-
-    bool operator==( SwapchainCreateInfoKHR const& rhs ) const
+    bool operator==( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( surface == rhs.surface )
-          && ( minImageCount == rhs.minImageCount )
-          && ( imageFormat == rhs.imageFormat )
-          && ( imageColorSpace == rhs.imageColorSpace )
-          && ( imageExtent == rhs.imageExtent )
-          && ( imageArrayLayers == rhs.imageArrayLayers )
-          && ( imageUsage == rhs.imageUsage )
-          && ( imageSharingMode == rhs.imageSharingMode )
-          && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
-          && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
-          && ( preTransform == rhs.preTransform )
-          && ( compositeAlpha == rhs.compositeAlpha )
-          && ( presentMode == rhs.presentMode )
-          && ( clipped == rhs.clipped )
-          && ( oldSwapchain == rhs.oldSwapchain );
+          && ( surface == rhs.surface );
     }
 
-    bool operator!=( SwapchainCreateInfoKHR const& rhs ) const
+    bool operator!=( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eSwapchainCreateInfoKHR;
+    StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR;
 
   public:
     const void* pNext = nullptr;
-    SwapchainCreateFlagsKHR flags;
     SurfaceKHR surface;
-    uint32_t minImageCount;
-    Format imageFormat;
-    ColorSpaceKHR imageColorSpace;
-    Extent2D imageExtent;
-    uint32_t imageArrayLayers;
-    ImageUsageFlags imageUsage;
-    SharingMode imageSharingMode;
-    uint32_t queueFamilyIndexCount;
-    const uint32_t* pQueueFamilyIndices;
-    SurfaceTransformFlagBitsKHR preTransform;
-    CompositeAlphaFlagBitsKHR compositeAlpha;
-    PresentModeKHR presentMode;
-    Bool32 clipped;
-    SwapchainKHR oldSwapchain;
   };
-  static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" );
 
-  enum class ViewportCoordinateSwizzleNV
+  struct PhysicalDeviceTransformFeedbackFeaturesEXT
   {
-    ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
-    eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV,
-    ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV,
-    eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV,
-    ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV,
-    eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV,
-    ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV,
-    eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV
+    PhysicalDeviceTransformFeedbackFeaturesEXT( Bool32 transformFeedback_ = 0,
+                                                Bool32 geometryStreams_ = 0 )
+      : transformFeedback( transformFeedback_ )
+      , geometryStreams( geometryStreams_ )
+    {}
+
+    PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) );
+    }
+
+    PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) );
+      return *this;
+    }
+
+    PhysicalDeviceTransformFeedbackFeaturesEXT & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceTransformFeedbackFeaturesEXT & setTransformFeedback( Bool32 transformFeedback_ )
+    {
+      transformFeedback = transformFeedback_;
+      return *this;
+    }
+
+    PhysicalDeviceTransformFeedbackFeaturesEXT & setGeometryStreams( Bool32 geometryStreams_ )
+    {
+      geometryStreams = geometryStreams_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceTransformFeedbackFeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDeviceTransformFeedbackFeaturesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( transformFeedback == rhs.transformFeedback )
+          && ( geometryStreams == rhs.geometryStreams );
+    }
+
+    bool operator!=( PhysicalDeviceTransformFeedbackFeaturesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 transformFeedback;
+    Bool32 geometryStreams;
   };
+  static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceTransformFeedbackPropertiesEXT
+  {
+    operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceTransformFeedbackPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDeviceTransformFeedbackPropertiesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( maxTransformFeedbackStreams == rhs.maxTransformFeedbackStreams )
+          && ( maxTransformFeedbackBuffers == rhs.maxTransformFeedbackBuffers )
+          && ( maxTransformFeedbackBufferSize == rhs.maxTransformFeedbackBufferSize )
+          && ( maxTransformFeedbackStreamDataSize == rhs.maxTransformFeedbackStreamDataSize )
+          && ( maxTransformFeedbackBufferDataSize == rhs.maxTransformFeedbackBufferDataSize )
+          && ( maxTransformFeedbackBufferDataStride == rhs.maxTransformFeedbackBufferDataStride )
+          && ( transformFeedbackQueries == rhs.transformFeedbackQueries )
+          && ( transformFeedbackStreamsLinesTriangles == rhs.transformFeedbackStreamsLinesTriangles )
+          && ( transformFeedbackRasterizationStreamSelect == rhs.transformFeedbackRasterizationStreamSelect )
+          && ( transformFeedbackDraw == rhs.transformFeedbackDraw );
+    }
+
+    bool operator!=( PhysicalDeviceTransformFeedbackPropertiesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t maxTransformFeedbackStreams;
+    uint32_t maxTransformFeedbackBuffers;
+    DeviceSize maxTransformFeedbackBufferSize;
+    uint32_t maxTransformFeedbackStreamDataSize;
+    uint32_t maxTransformFeedbackBufferDataSize;
+    uint32_t maxTransformFeedbackBufferDataStride;
+    Bool32 transformFeedbackQueries;
+    Bool32 transformFeedbackStreamsLinesTriangles;
+    Bool32 transformFeedbackRasterizationStreamSelect;
+    Bool32 transformFeedbackDraw;
+  };
+  static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceVariablePointerFeatures
+  {
+    PhysicalDeviceVariablePointerFeatures( Bool32 variablePointersStorageBuffer_ = 0,
+                                           Bool32 variablePointers_ = 0 )
+      : variablePointersStorageBuffer( variablePointersStorageBuffer_ )
+      , variablePointers( variablePointers_ )
+    {}
+
+    PhysicalDeviceVariablePointerFeatures( VkPhysicalDeviceVariablePointerFeatures const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeatures ) );
+    }
+
+    PhysicalDeviceVariablePointerFeatures& operator=( VkPhysicalDeviceVariablePointerFeatures const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeatures ) );
+      return *this;
+    }
+
+    PhysicalDeviceVariablePointerFeatures & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceVariablePointerFeatures & setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ )
+    {
+      variablePointersStorageBuffer = variablePointersStorageBuffer_;
+      return *this;
+    }
+
+    PhysicalDeviceVariablePointerFeatures & setVariablePointers( Bool32 variablePointers_ )
+    {
+      variablePointers = variablePointers_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceVariablePointerFeatures const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceVariablePointerFeatures*>( this );
+    }
+
+    operator VkPhysicalDeviceVariablePointerFeatures &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceVariablePointerFeatures*>( this );
+    }
+
+    bool operator==( PhysicalDeviceVariablePointerFeatures const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer )
+          && ( variablePointers == rhs.variablePointers );
+    }
+
+    bool operator!=( PhysicalDeviceVariablePointerFeatures const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceVariablePointerFeatures;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 variablePointersStorageBuffer;
+    Bool32 variablePointers;
+  };
+  static_assert( sizeof( PhysicalDeviceVariablePointerFeatures ) == sizeof( VkPhysicalDeviceVariablePointerFeatures ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT
+  {
+    PhysicalDeviceVertexAttributeDivisorFeaturesEXT( Bool32 vertexAttributeInstanceRateDivisor_ = 0,
+                                                     Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 )
+      : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ )
+      , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ )
+    {}
+
+    PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) );
+    }
+
+    PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) );
+      return *this;
+    }
+
+    PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ )
+    {
+      vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_;
+      return *this;
+    }
+
+    PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ )
+    {
+      vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor )
+          && ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor );
+    }
+
+    bool operator!=( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 vertexAttributeInstanceRateDivisor;
+    Bool32 vertexAttributeInstanceRateZeroDivisor;
+  };
+  static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT
+  {
+    PhysicalDeviceVertexAttributeDivisorPropertiesEXT( uint32_t maxVertexAttribDivisor_ = 0 )
+      : maxVertexAttribDivisor( maxVertexAttribDivisor_ )
+    {}
+
+    PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) );
+    }
+
+    PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) );
+      return *this;
+    }
+
+    PhysicalDeviceVertexAttributeDivisorPropertiesEXT & setPNext( void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceVertexAttributeDivisorPropertiesEXT & setMaxVertexAttribDivisor( uint32_t maxVertexAttribDivisor_ )
+    {
+      maxVertexAttribDivisor = maxVertexAttribDivisor_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>( this );
+    }
+
+    operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>( this );
+    }
+
+    bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor );
+    }
+
+    bool operator!=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t maxVertexAttribDivisor;
+  };
+  static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "struct and wrapper have different size!" );
+
+  struct PhysicalDeviceVulkanMemoryModelFeaturesKHR
+  {
+    operator VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const&() const
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>( this );
+    }
+
+    operator VkPhysicalDeviceVulkanMemoryModelFeaturesKHR &()
+    {
+      return *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>( this );
+    }
+
+    bool operator==( PhysicalDeviceVulkanMemoryModelFeaturesKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( vulkanMemoryModel == rhs.vulkanMemoryModel )
+          && ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope );
+    }
+
+    bool operator!=( PhysicalDeviceVulkanMemoryModelFeaturesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 vulkanMemoryModel;
+    Bool32 vulkanMemoryModelDeviceScope;
+  };
+  static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR ), "struct and wrapper have different size!" );
+
+  struct PipelineCacheCreateInfo
+  {
+    PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = PipelineCacheCreateFlags(),
+                             size_t initialDataSize_ = 0,
+                             const void* pInitialData_ = nullptr )
+      : flags( flags_ )
+      , initialDataSize( initialDataSize_ )
+      , pInitialData( pInitialData_ )
+    {}
+
+    PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) );
+    }
+
+    PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) );
+      return *this;
+    }
+
+    PipelineCacheCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineCacheCreateInfo & setFlags( PipelineCacheCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    PipelineCacheCreateInfo & setInitialDataSize( size_t initialDataSize_ )
+    {
+      initialDataSize = initialDataSize_;
+      return *this;
+    }
+
+    PipelineCacheCreateInfo & setPInitialData( const void* pInitialData_ )
+    {
+      pInitialData = pInitialData_;
+      return *this;
+    }
+
+    operator VkPipelineCacheCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkPipelineCacheCreateInfo*>( this );
+    }
+
+    operator VkPipelineCacheCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineCacheCreateInfo*>( this );
+    }
+
+    bool operator==( PipelineCacheCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( initialDataSize == rhs.initialDataSize )
+          && ( pInitialData == rhs.pInitialData );
+    }
+
+    bool operator!=( PipelineCacheCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineCacheCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    PipelineCacheCreateFlags flags;
+    size_t initialDataSize;
+    const void* pInitialData;
+  };
+  static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" );
+
+  struct PipelineColorBlendAdvancedStateCreateInfoEXT
+  {
+    PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0,
+                                                  Bool32 dstPremultiplied_ = 0,
+                                                  BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated )
+      : srcPremultiplied( srcPremultiplied_ )
+      , dstPremultiplied( dstPremultiplied_ )
+      , blendOverlap( blendOverlap_ )
+    {}
+
+    PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) );
+    }
+
+    PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) );
+      return *this;
+    }
+
+    PipelineColorBlendAdvancedStateCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineColorBlendAdvancedStateCreateInfoEXT & setSrcPremultiplied( Bool32 srcPremultiplied_ )
+    {
+      srcPremultiplied = srcPremultiplied_;
+      return *this;
+    }
+
+    PipelineColorBlendAdvancedStateCreateInfoEXT & setDstPremultiplied( Bool32 dstPremultiplied_ )
+    {
+      dstPremultiplied = dstPremultiplied_;
+      return *this;
+    }
+
+    PipelineColorBlendAdvancedStateCreateInfoEXT & setBlendOverlap( BlendOverlapEXT blendOverlap_ )
+    {
+      blendOverlap = blendOverlap_;
+      return *this;
+    }
+
+    operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>( this );
+    }
+
+    operator VkPipelineColorBlendAdvancedStateCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>( this );
+    }
+
+    bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( srcPremultiplied == rhs.srcPremultiplied )
+          && ( dstPremultiplied == rhs.dstPremultiplied )
+          && ( blendOverlap == rhs.blendOverlap );
+    }
+
+    bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    Bool32 srcPremultiplied;
+    Bool32 dstPremultiplied;
+    BlendOverlapEXT blendOverlap;
+  };
+  static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct PipelineCoverageModulationStateCreateInfoNV
+  {
+    PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(),
+                                                 CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone,
+                                                 Bool32 coverageModulationTableEnable_ = 0,
+                                                 uint32_t coverageModulationTableCount_ = 0,
+                                                 const float* pCoverageModulationTable_ = nullptr )
+      : flags( flags_ )
+      , coverageModulationMode( coverageModulationMode_ )
+      , coverageModulationTableEnable( coverageModulationTableEnable_ )
+      , coverageModulationTableCount( coverageModulationTableCount_ )
+      , pCoverageModulationTable( pCoverageModulationTable_ )
+    {}
+
+    PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
+    }
+
+    PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
+      return *this;
+    }
+
+    PipelineCoverageModulationStateCreateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineCoverageModulationStateCreateInfoNV & setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ )
+    {
+      coverageModulationMode = coverageModulationMode_;
+      return *this;
+    }
+
+    PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ )
+    {
+      coverageModulationTableEnable = coverageModulationTableEnable_;
+      return *this;
+    }
+
+    PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationTableCount( uint32_t coverageModulationTableCount_ )
+    {
+      coverageModulationTableCount = coverageModulationTableCount_;
+      return *this;
+    }
+
+    PipelineCoverageModulationStateCreateInfoNV & setPCoverageModulationTable( const float* pCoverageModulationTable_ )
+    {
+      pCoverageModulationTable = pCoverageModulationTable_;
+      return *this;
+    }
+
+    operator VkPipelineCoverageModulationStateCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>( this );
+    }
+
+    operator VkPipelineCoverageModulationStateCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>( this );
+    }
+
+    bool operator==( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( coverageModulationMode == rhs.coverageModulationMode )
+          && ( coverageModulationTableEnable == rhs.coverageModulationTableEnable )
+          && ( coverageModulationTableCount == rhs.coverageModulationTableCount )
+          && ( pCoverageModulationTable == rhs.pCoverageModulationTable );
+    }
+
+    bool operator!=( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    PipelineCoverageModulationStateCreateFlagsNV flags;
+    CoverageModulationModeNV coverageModulationMode;
+    Bool32 coverageModulationTableEnable;
+    uint32_t coverageModulationTableCount;
+    const float* pCoverageModulationTable;
+  };
+  static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" );
+
+  struct PipelineCoverageToColorStateCreateInfoNV
+  {
+    PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(),
+                                              Bool32 coverageToColorEnable_ = 0,
+                                              uint32_t coverageToColorLocation_ = 0 )
+      : flags( flags_ )
+      , coverageToColorEnable( coverageToColorEnable_ )
+      , coverageToColorLocation( coverageToColorLocation_ )
+    {}
+
+    PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) );
+    }
+
+    PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) );
+      return *this;
+    }
+
+    PipelineCoverageToColorStateCreateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineCoverageToColorStateCreateInfoNV & setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    PipelineCoverageToColorStateCreateInfoNV & setCoverageToColorEnable( Bool32 coverageToColorEnable_ )
+    {
+      coverageToColorEnable = coverageToColorEnable_;
+      return *this;
+    }
+
+    PipelineCoverageToColorStateCreateInfoNV & setCoverageToColorLocation( uint32_t coverageToColorLocation_ )
+    {
+      coverageToColorLocation = coverageToColorLocation_;
+      return *this;
+    }
+
+    operator VkPipelineCoverageToColorStateCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>( this );
+    }
+
+    operator VkPipelineCoverageToColorStateCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>( this );
+    }
+
+    bool operator==( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( coverageToColorEnable == rhs.coverageToColorEnable )
+          && ( coverageToColorLocation == rhs.coverageToColorLocation );
+    }
+
+    bool operator!=( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    PipelineCoverageToColorStateCreateFlagsNV flags;
+    Bool32 coverageToColorEnable;
+    uint32_t coverageToColorLocation;
+  };
+  static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" );
+
+  struct PipelineDiscardRectangleStateCreateInfoEXT
+  {
+    PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(),
+                                                DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive,
+                                                uint32_t discardRectangleCount_ = 0,
+                                                const Rect2D* pDiscardRectangles_ = nullptr )
+      : flags( flags_ )
+      , discardRectangleMode( discardRectangleMode_ )
+      , discardRectangleCount( discardRectangleCount_ )
+      , pDiscardRectangles( pDiscardRectangles_ )
+    {}
+
+    PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
+    }
+
+    PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
+      return *this;
+    }
+
+    PipelineDiscardRectangleStateCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineDiscardRectangleStateCreateInfoEXT & setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ )
+    {
+      discardRectangleMode = discardRectangleMode_;
+      return *this;
+    }
+
+    PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangleCount( uint32_t discardRectangleCount_ )
+    {
+      discardRectangleCount = discardRectangleCount_;
+      return *this;
+    }
+
+    PipelineDiscardRectangleStateCreateInfoEXT & setPDiscardRectangles( const Rect2D* pDiscardRectangles_ )
+    {
+      pDiscardRectangles = pDiscardRectangles_;
+      return *this;
+    }
+
+    operator VkPipelineDiscardRectangleStateCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>( this );
+    }
+
+    operator VkPipelineDiscardRectangleStateCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>( this );
+    }
+
+    bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( discardRectangleMode == rhs.discardRectangleMode )
+          && ( discardRectangleCount == rhs.discardRectangleCount )
+          && ( pDiscardRectangles == rhs.pDiscardRectangles );
+    }
+
+    bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    PipelineDiscardRectangleStateCreateFlagsEXT flags;
+    DiscardRectangleModeEXT discardRectangleMode;
+    uint32_t discardRectangleCount;
+    const Rect2D* pDiscardRectangles;
+  };
+  static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct PushConstantRange
+  {
+    PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(),
+                       uint32_t offset_ = 0,
+                       uint32_t size_ = 0 )
+      : stageFlags( stageFlags_ )
+      , offset( offset_ )
+      , size( size_ )
+    {}
+
+    PushConstantRange( VkPushConstantRange const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PushConstantRange ) );
+    }
+
+    PushConstantRange& operator=( VkPushConstantRange const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PushConstantRange ) );
+      return *this;
+    }
+
+    PushConstantRange & setStageFlags( ShaderStageFlags stageFlags_ )
+    {
+      stageFlags = stageFlags_;
+      return *this;
+    }
+
+    PushConstantRange & setOffset( uint32_t offset_ )
+    {
+      offset = offset_;
+      return *this;
+    }
+
+    PushConstantRange & setSize( uint32_t size_ )
+    {
+      size = size_;
+      return *this;
+    }
+
+    operator VkPushConstantRange const&() const
+    {
+      return *reinterpret_cast<const VkPushConstantRange*>( this );
+    }
+
+    operator VkPushConstantRange &()
+    {
+      return *reinterpret_cast<VkPushConstantRange*>( this );
+    }
+
+    bool operator==( PushConstantRange const& rhs ) const
+    {
+      return ( stageFlags == rhs.stageFlags )
+          && ( offset == rhs.offset )
+          && ( size == rhs.size );
+    }
+
+    bool operator!=( PushConstantRange const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ShaderStageFlags stageFlags;
+    uint32_t offset;
+    uint32_t size;
+  };
+  static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" );
+
+  struct PipelineLayoutCreateInfo
+  {
+    PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(),
+                              uint32_t setLayoutCount_ = 0,
+                              const DescriptorSetLayout* pSetLayouts_ = nullptr,
+                              uint32_t pushConstantRangeCount_ = 0,
+                              const PushConstantRange* pPushConstantRanges_ = nullptr )
+      : flags( flags_ )
+      , setLayoutCount( setLayoutCount_ )
+      , pSetLayouts( pSetLayouts_ )
+      , pushConstantRangeCount( pushConstantRangeCount_ )
+      , pPushConstantRanges( pPushConstantRanges_ )
+    {}
+
+    PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
+    }
+
+    PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
+      return *this;
+    }
+
+    PipelineLayoutCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineLayoutCreateInfo & setFlags( PipelineLayoutCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    PipelineLayoutCreateInfo & setSetLayoutCount( uint32_t setLayoutCount_ )
+    {
+      setLayoutCount = setLayoutCount_;
+      return *this;
+    }
+
+    PipelineLayoutCreateInfo & setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
+    {
+      pSetLayouts = pSetLayouts_;
+      return *this;
+    }
+
+    PipelineLayoutCreateInfo & setPushConstantRangeCount( uint32_t pushConstantRangeCount_ )
+    {
+      pushConstantRangeCount = pushConstantRangeCount_;
+      return *this;
+    }
+
+    PipelineLayoutCreateInfo & setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ )
+    {
+      pPushConstantRanges = pPushConstantRanges_;
+      return *this;
+    }
+
+    operator VkPipelineLayoutCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkPipelineLayoutCreateInfo*>( this );
+    }
+
+    operator VkPipelineLayoutCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineLayoutCreateInfo*>( this );
+    }
+
+    bool operator==( PipelineLayoutCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( setLayoutCount == rhs.setLayoutCount )
+          && ( pSetLayouts == rhs.pSetLayouts )
+          && ( pushConstantRangeCount == rhs.pushConstantRangeCount )
+          && ( pPushConstantRanges == rhs.pPushConstantRanges );
+    }
+
+    bool operator!=( PipelineLayoutCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineLayoutCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    PipelineLayoutCreateFlags flags;
+    uint32_t setLayoutCount;
+    const DescriptorSetLayout* pSetLayouts;
+    uint32_t pushConstantRangeCount;
+    const PushConstantRange* pPushConstantRanges;
+  };
+  static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" );
+
+  struct PipelineRasterizationConservativeStateCreateInfoEXT
+  {
+    PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = PipelineRasterizationConservativeStateCreateFlagsEXT(),
+                                                         ConservativeRasterizationModeEXT conservativeRasterizationMode_ = ConservativeRasterizationModeEXT::eDisabled,
+                                                         float extraPrimitiveOverestimationSize_ = 0 )
+      : flags( flags_ )
+      , conservativeRasterizationMode( conservativeRasterizationMode_ )
+      , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
+    {}
+
+    PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
+    }
+
+    PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
+      return *this;
+    }
+
+    PipelineRasterizationConservativeStateCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineRasterizationConservativeStateCreateInfoEXT & setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    PipelineRasterizationConservativeStateCreateInfoEXT & setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ )
+    {
+      conservativeRasterizationMode = conservativeRasterizationMode_;
+      return *this;
+    }
+
+    PipelineRasterizationConservativeStateCreateInfoEXT & setExtraPrimitiveOverestimationSize( float extraPrimitiveOverestimationSize_ )
+    {
+      extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_;
+      return *this;
+    }
+
+    operator VkPipelineRasterizationConservativeStateCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>( this );
+    }
+
+    operator VkPipelineRasterizationConservativeStateCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>( this );
+    }
+
+    bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( conservativeRasterizationMode == rhs.conservativeRasterizationMode )
+          && ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize );
+    }
+
+    bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    PipelineRasterizationConservativeStateCreateFlagsEXT flags;
+    ConservativeRasterizationModeEXT conservativeRasterizationMode;
+    float extraPrimitiveOverestimationSize;
+  };
+  static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct PipelineRasterizationStateRasterizationOrderAMD
+  {
+    PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict )
+      : rasterizationOrder( rasterizationOrder_ )
+    {}
+
+    PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
+    }
+
+    PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
+      return *this;
+    }
+
+    PipelineRasterizationStateRasterizationOrderAMD & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineRasterizationStateRasterizationOrderAMD & setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ )
+    {
+      rasterizationOrder = rasterizationOrder_;
+      return *this;
+    }
+
+    operator VkPipelineRasterizationStateRasterizationOrderAMD const&() const
+    {
+      return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>( this );
+    }
+
+    operator VkPipelineRasterizationStateRasterizationOrderAMD &()
+    {
+      return *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>( this );
+    }
+
+    bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( rasterizationOrder == rhs.rasterizationOrder );
+    }
+
+    bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
+
+  public:
+    const void* pNext = nullptr;
+    RasterizationOrderAMD rasterizationOrder;
+  };
+  static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
+
+  struct PipelineRasterizationStateStreamCreateInfoEXT
+  {
+    PipelineRasterizationStateStreamCreateInfoEXT( PipelineRasterizationStateStreamCreateFlagsEXT flags_ = PipelineRasterizationStateStreamCreateFlagsEXT(),
+                                                   uint32_t rasterizationStream_ = 0 )
+      : flags( flags_ )
+      , rasterizationStream( rasterizationStream_ )
+    {}
+
+    PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) );
+    }
+
+    PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) );
+      return *this;
+    }
+
+    PipelineRasterizationStateStreamCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineRasterizationStateStreamCreateInfoEXT & setFlags( PipelineRasterizationStateStreamCreateFlagsEXT flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    PipelineRasterizationStateStreamCreateInfoEXT & setRasterizationStream( uint32_t rasterizationStream_ )
+    {
+      rasterizationStream = rasterizationStream_;
+      return *this;
+    }
+
+    operator VkPipelineRasterizationStateStreamCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>( this );
+    }
+
+    operator VkPipelineRasterizationStateStreamCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>( this );
+    }
+
+    bool operator==( PipelineRasterizationStateStreamCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( rasterizationStream == rhs.rasterizationStream );
+    }
+
+    bool operator!=( PipelineRasterizationStateStreamCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    PipelineRasterizationStateStreamCreateFlagsEXT flags;
+    uint32_t rasterizationStream;
+  };
+  static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct PipelineRepresentativeFragmentTestStateCreateInfoNV
+  {
+    PipelineRepresentativeFragmentTestStateCreateInfoNV( Bool32 representativeFragmentTestEnable_ = 0 )
+      : representativeFragmentTestEnable( representativeFragmentTestEnable_ )
+    {}
+
+    PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) );
+    }
+
+    PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) );
+      return *this;
+    }
+
+    PipelineRepresentativeFragmentTestStateCreateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineRepresentativeFragmentTestStateCreateInfoNV & setRepresentativeFragmentTestEnable( Bool32 representativeFragmentTestEnable_ )
+    {
+      representativeFragmentTestEnable = representativeFragmentTestEnable_;
+      return *this;
+    }
+
+    operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>( this );
+    }
+
+    operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>( this );
+    }
+
+    bool operator==( PipelineRepresentativeFragmentTestStateCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable );
+    }
+
+    bool operator!=( PipelineRepresentativeFragmentTestStateCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    Bool32 representativeFragmentTestEnable;
+  };
+  static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "struct and wrapper have different size!" );
+
+  struct PipelineSampleLocationsStateCreateInfoEXT
+  {
+    PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = 0,
+                                               SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
+      : sampleLocationsEnable( sampleLocationsEnable_ )
+      , sampleLocationsInfo( sampleLocationsInfo_ )
+    {}
+
+    PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
+    }
+
+    PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
+      return *this;
+    }
+
+    PipelineSampleLocationsStateCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsEnable( Bool32 sampleLocationsEnable_ )
+    {
+      sampleLocationsEnable = sampleLocationsEnable_;
+      return *this;
+    }
+
+    PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+    {
+      sampleLocationsInfo = sampleLocationsInfo_;
+      return *this;
+    }
+
+    operator VkPipelineSampleLocationsStateCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>( this );
+    }
+
+    operator VkPipelineSampleLocationsStateCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>( this );
+    }
+
+    bool operator==( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( sampleLocationsEnable == rhs.sampleLocationsEnable )
+          && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+    }
+
+    bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    Bool32 sampleLocationsEnable;
+    SampleLocationsInfoEXT sampleLocationsInfo;
+  };
+  static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct PipelineTessellationDomainOriginStateCreateInfo
+  {
+    PipelineTessellationDomainOriginStateCreateInfo( TessellationDomainOrigin domainOrigin_ = TessellationDomainOrigin::eUpperLeft )
+      : domainOrigin( domainOrigin_ )
+    {}
+
+    PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) );
+    }
+
+    PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) );
+      return *this;
+    }
+
+    PipelineTessellationDomainOriginStateCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineTessellationDomainOriginStateCreateInfo & setDomainOrigin( TessellationDomainOrigin domainOrigin_ )
+    {
+      domainOrigin = domainOrigin_;
+      return *this;
+    }
+
+    operator VkPipelineTessellationDomainOriginStateCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>( this );
+    }
+
+    operator VkPipelineTessellationDomainOriginStateCreateInfo &()
+    {
+      return *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>( this );
+    }
+
+    bool operator==( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( domainOrigin == rhs.domainOrigin );
+    }
+
+    bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    TessellationDomainOrigin domainOrigin;
+  };
+  static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "struct and wrapper have different size!" );
+
+  struct VertexInputBindingDivisorDescriptionEXT
+  {
+    VertexInputBindingDivisorDescriptionEXT( uint32_t binding_ = 0,
+                                             uint32_t divisor_ = 0 )
+      : binding( binding_ )
+      , divisor( divisor_ )
+    {}
+
+    VertexInputBindingDivisorDescriptionEXT( VkVertexInputBindingDivisorDescriptionEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) );
+    }
+
+    VertexInputBindingDivisorDescriptionEXT& operator=( VkVertexInputBindingDivisorDescriptionEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) );
+      return *this;
+    }
+
+    VertexInputBindingDivisorDescriptionEXT & setBinding( uint32_t binding_ )
+    {
+      binding = binding_;
+      return *this;
+    }
+
+    VertexInputBindingDivisorDescriptionEXT & setDivisor( uint32_t divisor_ )
+    {
+      divisor = divisor_;
+      return *this;
+    }
+
+    operator VkVertexInputBindingDivisorDescriptionEXT const&() const
+    {
+      return *reinterpret_cast<const VkVertexInputBindingDivisorDescriptionEXT*>( this );
+    }
+
+    operator VkVertexInputBindingDivisorDescriptionEXT &()
+    {
+      return *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>( this );
+    }
+
+    bool operator==( VertexInputBindingDivisorDescriptionEXT const& rhs ) const
+    {
+      return ( binding == rhs.binding )
+          && ( divisor == rhs.divisor );
+    }
+
+    bool operator!=( VertexInputBindingDivisorDescriptionEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t binding;
+    uint32_t divisor;
+  };
+  static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" );
+
+  struct PipelineVertexInputDivisorStateCreateInfoEXT
+  {
+    PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0,
+                                                  const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr )
+      : vertexBindingDivisorCount( vertexBindingDivisorCount_ )
+      , pVertexBindingDivisors( pVertexBindingDivisors_ )
+    {}
+
+    PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) );
+    }
+
+    PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) );
+      return *this;
+    }
+
+    PipelineVertexInputDivisorStateCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineVertexInputDivisorStateCreateInfoEXT & setVertexBindingDivisorCount( uint32_t vertexBindingDivisorCount_ )
+    {
+      vertexBindingDivisorCount = vertexBindingDivisorCount_;
+      return *this;
+    }
+
+    PipelineVertexInputDivisorStateCreateInfoEXT & setPVertexBindingDivisors( const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ )
+    {
+      pVertexBindingDivisors = pVertexBindingDivisors_;
+      return *this;
+    }
+
+    operator VkPipelineVertexInputDivisorStateCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>( this );
+    }
+
+    operator VkPipelineVertexInputDivisorStateCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>( this );
+    }
+
+    bool operator==( PipelineVertexInputDivisorStateCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( vertexBindingDivisorCount == rhs.vertexBindingDivisorCount )
+          && ( pVertexBindingDivisors == rhs.pVertexBindingDivisors );
+    }
+
+    bool operator!=( PipelineVertexInputDivisorStateCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t vertexBindingDivisorCount;
+    const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors;
+  };
+  static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
+  {
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV( CoarseSampleOrderTypeNV sampleOrderType_ = CoarseSampleOrderTypeNV::eDefault,
+                                                        uint32_t customSampleOrderCount_ = 0,
+                                                        const CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr )
+      : sampleOrderType( sampleOrderType_ )
+      , customSampleOrderCount( customSampleOrderCount_ )
+      , pCustomSampleOrders( pCustomSampleOrders_ )
+    {}
+
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) );
+    }
+
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) );
+      return *this;
+    }
+
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV & setSampleOrderType( CoarseSampleOrderTypeNV sampleOrderType_ )
+    {
+      sampleOrderType = sampleOrderType_;
+      return *this;
+    }
+
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV & setCustomSampleOrderCount( uint32_t customSampleOrderCount_ )
+    {
+      customSampleOrderCount = customSampleOrderCount_;
+      return *this;
+    }
+
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV & setPCustomSampleOrders( const CoarseSampleOrderCustomNV* pCustomSampleOrders_ )
+    {
+      pCustomSampleOrders = pCustomSampleOrders_;
+      return *this;
+    }
+
+    operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>( this );
+    }
+
+    operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>( this );
+    }
+
+    bool operator==( PipelineViewportCoarseSampleOrderStateCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( sampleOrderType == rhs.sampleOrderType )
+          && ( customSampleOrderCount == rhs.customSampleOrderCount )
+          && ( pCustomSampleOrders == rhs.pCustomSampleOrders );
+    }
+
+    bool operator!=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    CoarseSampleOrderTypeNV sampleOrderType;
+    uint32_t customSampleOrderCount;
+    const CoarseSampleOrderCustomNV* pCustomSampleOrders;
+  };
+  static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "struct and wrapper have different size!" );
+
+  struct PipelineViewportExclusiveScissorStateCreateInfoNV
+  {
+    PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0,
+                                                       const Rect2D* pExclusiveScissors_ = nullptr )
+      : exclusiveScissorCount( exclusiveScissorCount_ )
+      , pExclusiveScissors( pExclusiveScissors_ )
+    {}
+
+    PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) );
+    }
+
+    PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) );
+      return *this;
+    }
+
+    PipelineViewportExclusiveScissorStateCreateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineViewportExclusiveScissorStateCreateInfoNV & setExclusiveScissorCount( uint32_t exclusiveScissorCount_ )
+    {
+      exclusiveScissorCount = exclusiveScissorCount_;
+      return *this;
+    }
+
+    PipelineViewportExclusiveScissorStateCreateInfoNV & setPExclusiveScissors( const Rect2D* pExclusiveScissors_ )
+    {
+      pExclusiveScissors = pExclusiveScissors_;
+      return *this;
+    }
+
+    operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>( this );
+    }
+
+    operator VkPipelineViewportExclusiveScissorStateCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>( this );
+    }
+
+    bool operator==( PipelineViewportExclusiveScissorStateCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( exclusiveScissorCount == rhs.exclusiveScissorCount )
+          && ( pExclusiveScissors == rhs.pExclusiveScissors );
+    }
+
+    bool operator!=( PipelineViewportExclusiveScissorStateCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t exclusiveScissorCount;
+    const Rect2D* pExclusiveScissors;
+  };
+  static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "struct and wrapper have different size!" );
+
+  struct ShadingRatePaletteNV
+  {
+    ShadingRatePaletteNV( uint32_t shadingRatePaletteEntryCount_ = 0,
+                          const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ = nullptr )
+      : shadingRatePaletteEntryCount( shadingRatePaletteEntryCount_ )
+      , pShadingRatePaletteEntries( pShadingRatePaletteEntries_ )
+    {}
+
+    ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) );
+    }
+
+    ShadingRatePaletteNV& operator=( VkShadingRatePaletteNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) );
+      return *this;
+    }
+
+    ShadingRatePaletteNV & setShadingRatePaletteEntryCount( uint32_t shadingRatePaletteEntryCount_ )
+    {
+      shadingRatePaletteEntryCount = shadingRatePaletteEntryCount_;
+      return *this;
+    }
+
+    ShadingRatePaletteNV & setPShadingRatePaletteEntries( const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ )
+    {
+      pShadingRatePaletteEntries = pShadingRatePaletteEntries_;
+      return *this;
+    }
+
+    operator VkShadingRatePaletteNV const&() const
+    {
+      return *reinterpret_cast<const VkShadingRatePaletteNV*>( this );
+    }
+
+    operator VkShadingRatePaletteNV &()
+    {
+      return *reinterpret_cast<VkShadingRatePaletteNV*>( this );
+    }
+
+    bool operator==( ShadingRatePaletteNV const& rhs ) const
+    {
+      return ( shadingRatePaletteEntryCount == rhs.shadingRatePaletteEntryCount )
+          && ( pShadingRatePaletteEntries == rhs.pShadingRatePaletteEntries );
+    }
+
+    bool operator!=( ShadingRatePaletteNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t shadingRatePaletteEntryCount;
+    const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries;
+  };
+  static_assert( sizeof( ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" );
+
+  struct PipelineViewportShadingRateImageStateCreateInfoNV
+  {
+    PipelineViewportShadingRateImageStateCreateInfoNV( Bool32 shadingRateImageEnable_ = 0,
+                                                       uint32_t viewportCount_ = 0,
+                                                       const ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr )
+      : shadingRateImageEnable( shadingRateImageEnable_ )
+      , viewportCount( viewportCount_ )
+      , pShadingRatePalettes( pShadingRatePalettes_ )
+    {}
+
+    PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) );
+    }
+
+    PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) );
+      return *this;
+    }
+
+    PipelineViewportShadingRateImageStateCreateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PipelineViewportShadingRateImageStateCreateInfoNV & setShadingRateImageEnable( Bool32 shadingRateImageEnable_ )
+    {
+      shadingRateImageEnable = shadingRateImageEnable_;
+      return *this;
+    }
+
+    PipelineViewportShadingRateImageStateCreateInfoNV & setViewportCount( uint32_t viewportCount_ )
+    {
+      viewportCount = viewportCount_;
+      return *this;
+    }
+
+    PipelineViewportShadingRateImageStateCreateInfoNV & setPShadingRatePalettes( const ShadingRatePaletteNV* pShadingRatePalettes_ )
+    {
+      pShadingRatePalettes = pShadingRatePalettes_;
+      return *this;
+    }
+
+    operator VkPipelineViewportShadingRateImageStateCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>( this );
+    }
+
+    operator VkPipelineViewportShadingRateImageStateCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>( this );
+    }
+
+    bool operator==( PipelineViewportShadingRateImageStateCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( shadingRateImageEnable == rhs.shadingRateImageEnable )
+          && ( viewportCount == rhs.viewportCount )
+          && ( pShadingRatePalettes == rhs.pShadingRatePalettes );
+    }
+
+    bool operator!=( PipelineViewportShadingRateImageStateCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    Bool32 shadingRateImageEnable;
+    uint32_t viewportCount;
+    const ShadingRatePaletteNV* pShadingRatePalettes;
+  };
+  static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "struct and wrapper have different size!" );
 
   struct ViewportSwizzleNV
   {
@@ -34827,8 +40090,7 @@ public:
       , y( y_ )
       , z( z_ )
       , w( w_ )
-    {
-    }
+    {}
 
     ViewportSwizzleNV( VkViewportSwizzleNV const & rhs )
     {
@@ -34840,25 +40102,26 @@ public:
       memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) );
       return *this;
     }
-    ViewportSwizzleNV& setX( ViewportCoordinateSwizzleNV x_ )
+
+    ViewportSwizzleNV & setX( ViewportCoordinateSwizzleNV x_ )
     {
       x = x_;
       return *this;
     }
 
-    ViewportSwizzleNV& setY( ViewportCoordinateSwizzleNV y_ )
+    ViewportSwizzleNV & setY( ViewportCoordinateSwizzleNV y_ )
     {
       y = y_;
       return *this;
     }
 
-    ViewportSwizzleNV& setZ( ViewportCoordinateSwizzleNV z_ )
+    ViewportSwizzleNV & setZ( ViewportCoordinateSwizzleNV z_ )
     {
       z = z_;
       return *this;
     }
 
-    ViewportSwizzleNV& setW( ViewportCoordinateSwizzleNV w_ )
+    ViewportSwizzleNV & setW( ViewportCoordinateSwizzleNV w_ )
     {
       w = w_;
       return *this;
@@ -34866,12 +40129,12 @@ public:
 
     operator VkViewportSwizzleNV const&() const
     {
-      return *reinterpret_cast<const VkViewportSwizzleNV*>(this);
+      return *reinterpret_cast<const VkViewportSwizzleNV*>( this );
     }
 
     operator VkViewportSwizzleNV &()
     {
-      return *reinterpret_cast<VkViewportSwizzleNV*>(this);
+      return *reinterpret_cast<VkViewportSwizzleNV*>( this );
     }
 
     bool operator==( ViewportSwizzleNV const& rhs ) const
@@ -34902,8 +40165,7 @@ public:
       : flags( flags_ )
       , viewportCount( viewportCount_ )
       , pViewportSwizzles( pViewportSwizzles_ )
-    {
-    }
+    {}
 
     PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
     {
@@ -34915,25 +40177,26 @@ public:
       memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
       return *this;
     }
-    PipelineViewportSwizzleStateCreateInfoNV& setPNext( const void* pNext_ )
+
+    PipelineViewportSwizzleStateCreateInfoNV & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PipelineViewportSwizzleStateCreateInfoNV& setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ )
+    PipelineViewportSwizzleStateCreateInfoNV & setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    PipelineViewportSwizzleStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ )
+    PipelineViewportSwizzleStateCreateInfoNV & setViewportCount( uint32_t viewportCount_ )
     {
       viewportCount = viewportCount_;
       return *this;
     }
 
-    PipelineViewportSwizzleStateCreateInfoNV& setPViewportSwizzles( const ViewportSwizzleNV* pViewportSwizzles_ )
+    PipelineViewportSwizzleStateCreateInfoNV & setPViewportSwizzles( const ViewportSwizzleNV* pViewportSwizzles_ )
     {
       pViewportSwizzles = pViewportSwizzles_;
       return *this;
@@ -34941,12 +40204,12 @@ public:
 
     operator VkPipelineViewportSwizzleStateCreateInfoNV const&() const
     {
-      return *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(this);
+      return *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>( this );
     }
 
     operator VkPipelineViewportSwizzleStateCreateInfoNV &()
     {
-      return *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(this);
+      return *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>( this );
     }
 
     bool operator==( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const
@@ -34974,127 +40237,1194 @@ public:
   };
   static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" );
 
-  enum class DiscardRectangleModeEXT
+  struct ViewportWScalingNV
   {
-    eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
-    eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT
-  };
+    ViewportWScalingNV( float xcoeff_ = 0,
+                        float ycoeff_ = 0 )
+      : xcoeff( xcoeff_ )
+      , ycoeff( ycoeff_ )
+    {}
 
-  struct PipelineDiscardRectangleStateCreateInfoEXT
-  {
-    PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(),
-                                                DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive,
-                                                uint32_t discardRectangleCount_ = 0,
-                                                const Rect2D* pDiscardRectangles_ = nullptr )
-      : flags( flags_ )
-      , discardRectangleMode( discardRectangleMode_ )
-      , discardRectangleCount( discardRectangleCount_ )
-      , pDiscardRectangles( pDiscardRectangles_ )
+    ViewportWScalingNV( VkViewportWScalingNV const & rhs )
     {
+      memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
     }
 
-    PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
+    ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs )
     {
-      memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
-    }
-
-    PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
+      memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
       return *this;
     }
-    PipelineDiscardRectangleStateCreateInfoEXT& setPNext( const void* pNext_ )
+
+    ViewportWScalingNV & setXcoeff( float xcoeff_ )
+    {
+      xcoeff = xcoeff_;
+      return *this;
+    }
+
+    ViewportWScalingNV & setYcoeff( float ycoeff_ )
+    {
+      ycoeff = ycoeff_;
+      return *this;
+    }
+
+    operator VkViewportWScalingNV const&() const
+    {
+      return *reinterpret_cast<const VkViewportWScalingNV*>( this );
+    }
+
+    operator VkViewportWScalingNV &()
+    {
+      return *reinterpret_cast<VkViewportWScalingNV*>( this );
+    }
+
+    bool operator==( ViewportWScalingNV const& rhs ) const
+    {
+      return ( xcoeff == rhs.xcoeff )
+          && ( ycoeff == rhs.ycoeff );
+    }
+
+    bool operator!=( ViewportWScalingNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    float xcoeff;
+    float ycoeff;
+  };
+  static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" );
+
+  struct PipelineViewportWScalingStateCreateInfoNV
+  {
+    PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = 0,
+                                               uint32_t viewportCount_ = 0,
+                                               const ViewportWScalingNV* pViewportWScalings_ = nullptr )
+      : viewportWScalingEnable( viewportWScalingEnable_ )
+      , viewportCount( viewportCount_ )
+      , pViewportWScalings( pViewportWScalings_ )
+    {}
+
+    PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) );
+    }
+
+    PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) );
+      return *this;
+    }
+
+    PipelineViewportWScalingStateCreateInfoNV & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    PipelineDiscardRectangleStateCreateInfoEXT& setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ )
+    PipelineViewportWScalingStateCreateInfoNV & setViewportWScalingEnable( Bool32 viewportWScalingEnable_ )
     {
-      flags = flags_;
+      viewportWScalingEnable = viewportWScalingEnable_;
       return *this;
     }
 
-    PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ )
+    PipelineViewportWScalingStateCreateInfoNV & setViewportCount( uint32_t viewportCount_ )
     {
-      discardRectangleMode = discardRectangleMode_;
+      viewportCount = viewportCount_;
       return *this;
     }
 
-    PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleCount( uint32_t discardRectangleCount_ )
+    PipelineViewportWScalingStateCreateInfoNV & setPViewportWScalings( const ViewportWScalingNV* pViewportWScalings_ )
     {
-      discardRectangleCount = discardRectangleCount_;
+      pViewportWScalings = pViewportWScalings_;
       return *this;
     }
 
-    PipelineDiscardRectangleStateCreateInfoEXT& setPDiscardRectangles( const Rect2D* pDiscardRectangles_ )
+    operator VkPipelineViewportWScalingStateCreateInfoNV const&() const
     {
-      pDiscardRectangles = pDiscardRectangles_;
-      return *this;
+      return *reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>( this );
     }
 
-    operator VkPipelineDiscardRectangleStateCreateInfoEXT const&() const
+    operator VkPipelineViewportWScalingStateCreateInfoNV &()
     {
-      return *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(this);
+      return *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>( this );
     }
 
-    operator VkPipelineDiscardRectangleStateCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this);
-    }
-
-    bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const
+    bool operator==( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( discardRectangleMode == rhs.discardRectangleMode )
-          && ( discardRectangleCount == rhs.discardRectangleCount )
-          && ( pDiscardRectangles == rhs.pDiscardRectangles );
+          && ( viewportWScalingEnable == rhs.viewportWScalingEnable )
+          && ( viewportCount == rhs.viewportCount )
+          && ( pViewportWScalings == rhs.pViewportWScalings );
     }
 
-    bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const
+    bool operator!=( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT;
+    StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV;
 
   public:
     const void* pNext = nullptr;
-    PipelineDiscardRectangleStateCreateFlagsEXT flags;
-    DiscardRectangleModeEXT discardRectangleMode;
-    uint32_t discardRectangleCount;
-    const Rect2D* pDiscardRectangles;
+    Bool32 viewportWScalingEnable;
+    uint32_t viewportCount;
+    const ViewportWScalingNV* pViewportWScalings;
   };
-  static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" );
+  static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" );
 
-  enum class SubpassDescriptionFlagBits
+  struct PresentInfoKHR
   {
-    ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX,
-    ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX
-  };
+    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 )
+      : waitSemaphoreCount( waitSemaphoreCount_ )
+      , pWaitSemaphores( pWaitSemaphores_ )
+      , swapchainCount( swapchainCount_ )
+      , pSwapchains( pSwapchains_ )
+      , pImageIndices( pImageIndices_ )
+      , pResults( pResults_ )
+    {}
 
-  using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits, VkSubpassDescriptionFlags>;
-
-  VULKAN_HPP_INLINE SubpassDescriptionFlags operator|( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
-  {
-    return SubpassDescriptionFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SubpassDescriptionFlags operator~( SubpassDescriptionFlagBits bits )
-  {
-    return ~( SubpassDescriptionFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<SubpassDescriptionFlagBits>
-  {
-    enum
+    PresentInfoKHR( VkPresentInfoKHR const & rhs )
     {
-      allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) | VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX)
-    };
+      memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
+    }
+
+    PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
+      return *this;
+    }
+
+    PresentInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PresentInfoKHR & setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
+    {
+      waitSemaphoreCount = waitSemaphoreCount_;
+      return *this;
+    }
+
+    PresentInfoKHR & setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+    {
+      pWaitSemaphores = pWaitSemaphores_;
+      return *this;
+    }
+
+    PresentInfoKHR & setSwapchainCount( uint32_t swapchainCount_ )
+    {
+      swapchainCount = swapchainCount_;
+      return *this;
+    }
+
+    PresentInfoKHR & setPSwapchains( const SwapchainKHR* pSwapchains_ )
+    {
+      pSwapchains = pSwapchains_;
+      return *this;
+    }
+
+    PresentInfoKHR & setPImageIndices( const uint32_t* pImageIndices_ )
+    {
+      pImageIndices = pImageIndices_;
+      return *this;
+    }
+
+    PresentInfoKHR & setPResults( Result* pResults_ )
+    {
+      pResults = pResults_;
+      return *this;
+    }
+
+    operator VkPresentInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkPresentInfoKHR*>( this );
+    }
+
+    operator VkPresentInfoKHR &()
+    {
+      return *reinterpret_cast<VkPresentInfoKHR*>( this );
+    }
+
+    bool operator==( PresentInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
+          && ( pWaitSemaphores == rhs.pWaitSemaphores )
+          && ( swapchainCount == rhs.swapchainCount )
+          && ( pSwapchains == rhs.pSwapchains )
+          && ( pImageIndices == rhs.pImageIndices )
+          && ( pResults == rhs.pResults );
+    }
+
+    bool operator!=( PresentInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePresentInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t waitSemaphoreCount;
+    const Semaphore* pWaitSemaphores;
+    uint32_t swapchainCount;
+    const SwapchainKHR* pSwapchains;
+    const uint32_t* pImageIndices;
+    Result* pResults;
   };
+  static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" );
+
+  struct RectLayerKHR
+  {
+    RectLayerKHR( Offset2D offset_ = Offset2D(),
+                  Extent2D extent_ = Extent2D(),
+                  uint32_t layer_ = 0 )
+      : offset( offset_ )
+      , extent( extent_ )
+      , layer( layer_ )
+    {}
+
+    explicit RectLayerKHR( Rect2D const& rect2D,
+                           uint32_t layer_ = 0 )
+      : offset( rect2D.offset )
+      , extent( rect2D.extent )
+      , layer( layer_ )
+    {}
+
+    RectLayerKHR( VkRectLayerKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RectLayerKHR ) );
+    }
+
+    RectLayerKHR& operator=( VkRectLayerKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RectLayerKHR ) );
+      return *this;
+    }
+
+    RectLayerKHR & setOffset( Offset2D offset_ )
+    {
+      offset = offset_;
+      return *this;
+    }
+
+    RectLayerKHR & setExtent( Extent2D extent_ )
+    {
+      extent = extent_;
+      return *this;
+    }
+
+    RectLayerKHR & setLayer( uint32_t layer_ )
+    {
+      layer = layer_;
+      return *this;
+    }
+
+    operator VkRectLayerKHR const&() const
+    {
+      return *reinterpret_cast<const VkRectLayerKHR*>( this );
+    }
+
+    operator VkRectLayerKHR &()
+    {
+      return *reinterpret_cast<VkRectLayerKHR*>( this );
+    }
+
+    bool operator==( RectLayerKHR const& rhs ) const
+    {
+      return ( offset == rhs.offset )
+          && ( extent == rhs.extent )
+          && ( layer == rhs.layer );
+    }
+
+    bool operator!=( RectLayerKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    Offset2D offset;
+    Extent2D extent;
+    uint32_t layer;
+  };
+  static_assert( sizeof( RectLayerKHR ) == sizeof( VkRectLayerKHR ), "struct and wrapper have different size!" );
+
+  struct PresentRegionKHR
+  {
+    PresentRegionKHR( uint32_t rectangleCount_ = 0,
+                      const RectLayerKHR* pRectangles_ = nullptr )
+      : rectangleCount( rectangleCount_ )
+      , pRectangles( pRectangles_ )
+    {}
+
+    PresentRegionKHR( VkPresentRegionKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
+    }
+
+    PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
+      return *this;
+    }
+
+    PresentRegionKHR & setRectangleCount( uint32_t rectangleCount_ )
+    {
+      rectangleCount = rectangleCount_;
+      return *this;
+    }
+
+    PresentRegionKHR & setPRectangles( const RectLayerKHR* pRectangles_ )
+    {
+      pRectangles = pRectangles_;
+      return *this;
+    }
+
+    operator VkPresentRegionKHR const&() const
+    {
+      return *reinterpret_cast<const VkPresentRegionKHR*>( this );
+    }
+
+    operator VkPresentRegionKHR &()
+    {
+      return *reinterpret_cast<VkPresentRegionKHR*>( this );
+    }
+
+    bool operator==( PresentRegionKHR const& rhs ) const
+    {
+      return ( rectangleCount == rhs.rectangleCount )
+          && ( pRectangles == rhs.pRectangles );
+    }
+
+    bool operator!=( PresentRegionKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t rectangleCount;
+    const RectLayerKHR* pRectangles;
+  };
+  static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" );
+
+  struct PresentRegionsKHR
+  {
+    PresentRegionsKHR( uint32_t swapchainCount_ = 0,
+                       const PresentRegionKHR* pRegions_ = nullptr )
+      : swapchainCount( swapchainCount_ )
+      , pRegions( pRegions_ )
+    {}
+
+    PresentRegionsKHR( VkPresentRegionsKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PresentRegionsKHR ) );
+    }
+
+    PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PresentRegionsKHR ) );
+      return *this;
+    }
+
+    PresentRegionsKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PresentRegionsKHR & setSwapchainCount( uint32_t swapchainCount_ )
+    {
+      swapchainCount = swapchainCount_;
+      return *this;
+    }
+
+    PresentRegionsKHR & setPRegions( const PresentRegionKHR* pRegions_ )
+    {
+      pRegions = pRegions_;
+      return *this;
+    }
+
+    operator VkPresentRegionsKHR const&() const
+    {
+      return *reinterpret_cast<const VkPresentRegionsKHR*>( this );
+    }
+
+    operator VkPresentRegionsKHR &()
+    {
+      return *reinterpret_cast<VkPresentRegionsKHR*>( this );
+    }
+
+    bool operator==( PresentRegionsKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( swapchainCount == rhs.swapchainCount )
+          && ( pRegions == rhs.pRegions );
+    }
+
+    bool operator!=( PresentRegionsKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePresentRegionsKHR;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t swapchainCount;
+    const PresentRegionKHR* pRegions;
+  };
+  static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" );
+
+  struct PresentTimeGOOGLE
+  {
+    PresentTimeGOOGLE( uint32_t presentID_ = 0,
+                       uint64_t desiredPresentTime_ = 0 )
+      : presentID( presentID_ )
+      , desiredPresentTime( desiredPresentTime_ )
+    {}
+
+    PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
+    }
+
+    PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
+      return *this;
+    }
+
+    PresentTimeGOOGLE & setPresentID( uint32_t presentID_ )
+    {
+      presentID = presentID_;
+      return *this;
+    }
+
+    PresentTimeGOOGLE & setDesiredPresentTime( uint64_t desiredPresentTime_ )
+    {
+      desiredPresentTime = desiredPresentTime_;
+      return *this;
+    }
+
+    operator VkPresentTimeGOOGLE const&() const
+    {
+      return *reinterpret_cast<const VkPresentTimeGOOGLE*>( this );
+    }
+
+    operator VkPresentTimeGOOGLE &()
+    {
+      return *reinterpret_cast<VkPresentTimeGOOGLE*>( this );
+    }
+
+    bool operator==( PresentTimeGOOGLE const& rhs ) const
+    {
+      return ( presentID == rhs.presentID )
+          && ( desiredPresentTime == rhs.desiredPresentTime );
+    }
+
+    bool operator!=( PresentTimeGOOGLE const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t presentID;
+    uint64_t desiredPresentTime;
+  };
+  static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" );
+
+  struct PresentTimesInfoGOOGLE
+  {
+    PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0,
+                            const PresentTimeGOOGLE* pTimes_ = nullptr )
+      : swapchainCount( swapchainCount_ )
+      , pTimes( pTimes_ )
+    {}
+
+    PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) );
+    }
+
+    PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) );
+      return *this;
+    }
+
+    PresentTimesInfoGOOGLE & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PresentTimesInfoGOOGLE & setSwapchainCount( uint32_t swapchainCount_ )
+    {
+      swapchainCount = swapchainCount_;
+      return *this;
+    }
+
+    PresentTimesInfoGOOGLE & setPTimes( const PresentTimeGOOGLE* pTimes_ )
+    {
+      pTimes = pTimes_;
+      return *this;
+    }
+
+    operator VkPresentTimesInfoGOOGLE const&() const
+    {
+      return *reinterpret_cast<const VkPresentTimesInfoGOOGLE*>( this );
+    }
+
+    operator VkPresentTimesInfoGOOGLE &()
+    {
+      return *reinterpret_cast<VkPresentTimesInfoGOOGLE*>( this );
+    }
+
+    bool operator==( PresentTimesInfoGOOGLE const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( swapchainCount == rhs.swapchainCount )
+          && ( pTimes == rhs.pTimes );
+    }
+
+    bool operator!=( PresentTimesInfoGOOGLE const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::ePresentTimesInfoGOOGLE;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t swapchainCount;
+    const PresentTimeGOOGLE* pTimes;
+  };
+  static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "struct and wrapper have different size!" );
+
+  struct ProtectedSubmitInfo
+  {
+    ProtectedSubmitInfo( Bool32 protectedSubmit_ = 0 )
+      : protectedSubmit( protectedSubmit_ )
+    {}
+
+    ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ProtectedSubmitInfo ) );
+    }
+
+    ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ProtectedSubmitInfo ) );
+      return *this;
+    }
+
+    ProtectedSubmitInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ProtectedSubmitInfo & setProtectedSubmit( Bool32 protectedSubmit_ )
+    {
+      protectedSubmit = protectedSubmit_;
+      return *this;
+    }
+
+    operator VkProtectedSubmitInfo const&() const
+    {
+      return *reinterpret_cast<const VkProtectedSubmitInfo*>( this );
+    }
+
+    operator VkProtectedSubmitInfo &()
+    {
+      return *reinterpret_cast<VkProtectedSubmitInfo*>( this );
+    }
+
+    bool operator==( ProtectedSubmitInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( protectedSubmit == rhs.protectedSubmit );
+    }
+
+    bool operator!=( ProtectedSubmitInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eProtectedSubmitInfo;
+
+  public:
+    const void* pNext = nullptr;
+    Bool32 protectedSubmit;
+  };
+  static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "struct and wrapper have different size!" );
+
+  struct QueryPoolCreateInfo
+  {
+    QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(),
+                         QueryType queryType_ = QueryType::eOcclusion,
+                         uint32_t queryCount_ = 0,
+                         QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
+      : flags( flags_ )
+      , queryType( queryType_ )
+      , queryCount( queryCount_ )
+      , pipelineStatistics( pipelineStatistics_ )
+    {}
+
+    QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
+    }
+
+    QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
+      return *this;
+    }
+
+    QueryPoolCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    QueryPoolCreateInfo & setFlags( QueryPoolCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    QueryPoolCreateInfo & setQueryType( QueryType queryType_ )
+    {
+      queryType = queryType_;
+      return *this;
+    }
+
+    QueryPoolCreateInfo & setQueryCount( uint32_t queryCount_ )
+    {
+      queryCount = queryCount_;
+      return *this;
+    }
+
+    QueryPoolCreateInfo & setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
+    {
+      pipelineStatistics = pipelineStatistics_;
+      return *this;
+    }
+
+    operator VkQueryPoolCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkQueryPoolCreateInfo*>( this );
+    }
+
+    operator VkQueryPoolCreateInfo &()
+    {
+      return *reinterpret_cast<VkQueryPoolCreateInfo*>( this );
+    }
+
+    bool operator==( QueryPoolCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( queryType == rhs.queryType )
+          && ( queryCount == rhs.queryCount )
+          && ( pipelineStatistics == rhs.pipelineStatistics );
+    }
+
+    bool operator!=( QueryPoolCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eQueryPoolCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    QueryPoolCreateFlags flags;
+    QueryType queryType;
+    uint32_t queryCount;
+    QueryPipelineStatisticFlags pipelineStatistics;
+  };
+  static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" );
+
+  struct QueueFamilyCheckpointPropertiesNV
+  {
+    operator VkQueueFamilyCheckpointPropertiesNV const&() const
+    {
+      return *reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>( this );
+    }
+
+    operator VkQueueFamilyCheckpointPropertiesNV &()
+    {
+      return *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>( this );
+    }
+
+    bool operator==( QueueFamilyCheckpointPropertiesNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask );
+    }
+
+    bool operator!=( QueueFamilyCheckpointPropertiesNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV;
+
+  public:
+    void* pNext = nullptr;
+    PipelineStageFlags checkpointExecutionStageMask;
+  };
+  static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "struct and wrapper have different size!" );
+
+  struct QueueFamilyProperties
+  {
+    operator VkQueueFamilyProperties const&() const
+    {
+      return *reinterpret_cast<const VkQueueFamilyProperties*>( this );
+    }
+
+    operator VkQueueFamilyProperties &()
+    {
+      return *reinterpret_cast<VkQueueFamilyProperties*>( this );
+    }
+
+    bool operator==( QueueFamilyProperties const& rhs ) const
+    {
+      return ( queueFlags == rhs.queueFlags )
+          && ( queueCount == rhs.queueCount )
+          && ( timestampValidBits == rhs.timestampValidBits )
+          && ( minImageTransferGranularity == rhs.minImageTransferGranularity );
+    }
+
+    bool operator!=( QueueFamilyProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    QueueFlags queueFlags;
+    uint32_t queueCount;
+    uint32_t timestampValidBits;
+    Extent3D minImageTransferGranularity;
+  };
+  static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" );
+
+  struct QueueFamilyProperties2
+  {
+    operator VkQueueFamilyProperties2 const&() const
+    {
+      return *reinterpret_cast<const VkQueueFamilyProperties2*>( this );
+    }
+
+    operator VkQueueFamilyProperties2 &()
+    {
+      return *reinterpret_cast<VkQueueFamilyProperties2*>( this );
+    }
+
+    bool operator==( QueueFamilyProperties2 const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( queueFamilyProperties == rhs.queueFamilyProperties );
+    }
+
+    bool operator!=( QueueFamilyProperties2 const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eQueueFamilyProperties2;
+
+  public:
+    void* pNext = nullptr;
+    QueueFamilyProperties queueFamilyProperties;
+  };
+  static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" );
+
+  struct RayTracingShaderGroupCreateInfoNV
+  {
+    RayTracingShaderGroupCreateInfoNV( RayTracingShaderGroupTypeNV type_ = RayTracingShaderGroupTypeNV::eGeneral,
+                                       uint32_t generalShader_ = 0,
+                                       uint32_t closestHitShader_ = 0,
+                                       uint32_t anyHitShader_ = 0,
+                                       uint32_t intersectionShader_ = 0 )
+      : type( type_ )
+      , generalShader( generalShader_ )
+      , closestHitShader( closestHitShader_ )
+      , anyHitShader( anyHitShader_ )
+      , intersectionShader( intersectionShader_ )
+    {}
+
+    RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) );
+    }
+
+    RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) );
+      return *this;
+    }
+
+    RayTracingShaderGroupCreateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    RayTracingShaderGroupCreateInfoNV & setType( RayTracingShaderGroupTypeNV type_ )
+    {
+      type = type_;
+      return *this;
+    }
+
+    RayTracingShaderGroupCreateInfoNV & setGeneralShader( uint32_t generalShader_ )
+    {
+      generalShader = generalShader_;
+      return *this;
+    }
+
+    RayTracingShaderGroupCreateInfoNV & setClosestHitShader( uint32_t closestHitShader_ )
+    {
+      closestHitShader = closestHitShader_;
+      return *this;
+    }
+
+    RayTracingShaderGroupCreateInfoNV & setAnyHitShader( uint32_t anyHitShader_ )
+    {
+      anyHitShader = anyHitShader_;
+      return *this;
+    }
+
+    RayTracingShaderGroupCreateInfoNV & setIntersectionShader( uint32_t intersectionShader_ )
+    {
+      intersectionShader = intersectionShader_;
+      return *this;
+    }
+
+    operator VkRayTracingShaderGroupCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoNV*>( this );
+    }
+
+    operator VkRayTracingShaderGroupCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>( this );
+    }
+
+    bool operator==( RayTracingShaderGroupCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( type == rhs.type )
+          && ( generalShader == rhs.generalShader )
+          && ( closestHitShader == rhs.closestHitShader )
+          && ( anyHitShader == rhs.anyHitShader )
+          && ( intersectionShader == rhs.intersectionShader );
+    }
+
+    bool operator!=( RayTracingShaderGroupCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    RayTracingShaderGroupTypeNV type;
+    uint32_t generalShader;
+    uint32_t closestHitShader;
+    uint32_t anyHitShader;
+    uint32_t intersectionShader;
+  };
+  static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "struct and wrapper have different size!" );
+
+  struct RayTracingPipelineCreateInfoNV
+  {
+    RayTracingPipelineCreateInfoNV( PipelineCreateFlags flags_ = PipelineCreateFlags(),
+                                    uint32_t stageCount_ = 0,
+                                    const PipelineShaderStageCreateInfo* pStages_ = nullptr,
+                                    uint32_t groupCount_ = 0,
+                                    const RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr,
+                                    uint32_t maxRecursionDepth_ = 0,
+                                    PipelineLayout layout_ = PipelineLayout(),
+                                    Pipeline basePipelineHandle_ = Pipeline(),
+                                    int32_t basePipelineIndex_ = 0 )
+      : flags( flags_ )
+      , stageCount( stageCount_ )
+      , pStages( pStages_ )
+      , groupCount( groupCount_ )
+      , pGroups( pGroups_ )
+      , maxRecursionDepth( maxRecursionDepth_ )
+      , layout( layout_ )
+      , basePipelineHandle( basePipelineHandle_ )
+      , basePipelineIndex( basePipelineIndex_ )
+    {}
+
+    RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) );
+    }
+
+    RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) );
+      return *this;
+    }
+
+    RayTracingPipelineCreateInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    RayTracingPipelineCreateInfoNV & setFlags( PipelineCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    RayTracingPipelineCreateInfoNV & setStageCount( uint32_t stageCount_ )
+    {
+      stageCount = stageCount_;
+      return *this;
+    }
+
+    RayTracingPipelineCreateInfoNV & setPStages( const PipelineShaderStageCreateInfo* pStages_ )
+    {
+      pStages = pStages_;
+      return *this;
+    }
+
+    RayTracingPipelineCreateInfoNV & setGroupCount( uint32_t groupCount_ )
+    {
+      groupCount = groupCount_;
+      return *this;
+    }
+
+    RayTracingPipelineCreateInfoNV & setPGroups( const RayTracingShaderGroupCreateInfoNV* pGroups_ )
+    {
+      pGroups = pGroups_;
+      return *this;
+    }
+
+    RayTracingPipelineCreateInfoNV & setMaxRecursionDepth( uint32_t maxRecursionDepth_ )
+    {
+      maxRecursionDepth = maxRecursionDepth_;
+      return *this;
+    }
+
+    RayTracingPipelineCreateInfoNV & setLayout( PipelineLayout layout_ )
+    {
+      layout = layout_;
+      return *this;
+    }
+
+    RayTracingPipelineCreateInfoNV & setBasePipelineHandle( Pipeline basePipelineHandle_ )
+    {
+      basePipelineHandle = basePipelineHandle_;
+      return *this;
+    }
+
+    RayTracingPipelineCreateInfoNV & setBasePipelineIndex( int32_t basePipelineIndex_ )
+    {
+      basePipelineIndex = basePipelineIndex_;
+      return *this;
+    }
+
+    operator VkRayTracingPipelineCreateInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( this );
+    }
+
+    operator VkRayTracingPipelineCreateInfoNV &()
+    {
+      return *reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>( this );
+    }
+
+    bool operator==( RayTracingPipelineCreateInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( stageCount == rhs.stageCount )
+          && ( pStages == rhs.pStages )
+          && ( groupCount == rhs.groupCount )
+          && ( pGroups == rhs.pGroups )
+          && ( maxRecursionDepth == rhs.maxRecursionDepth )
+          && ( layout == rhs.layout )
+          && ( basePipelineHandle == rhs.basePipelineHandle )
+          && ( basePipelineIndex == rhs.basePipelineIndex );
+    }
+
+    bool operator!=( RayTracingPipelineCreateInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    PipelineCreateFlags flags;
+    uint32_t stageCount;
+    const PipelineShaderStageCreateInfo* pStages;
+    uint32_t groupCount;
+    const RayTracingShaderGroupCreateInfoNV* pGroups;
+    uint32_t maxRecursionDepth;
+    PipelineLayout layout;
+    Pipeline basePipelineHandle;
+    int32_t basePipelineIndex;
+  };
+  static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "struct and wrapper have different size!" );
+
+  struct RefreshCycleDurationGOOGLE
+  {
+    operator VkRefreshCycleDurationGOOGLE const&() const
+    {
+      return *reinterpret_cast<const VkRefreshCycleDurationGOOGLE*>( this );
+    }
+
+    operator VkRefreshCycleDurationGOOGLE &()
+    {
+      return *reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( this );
+    }
+
+    bool operator==( RefreshCycleDurationGOOGLE const& rhs ) const
+    {
+      return ( refreshDuration == rhs.refreshDuration );
+    }
+
+    bool operator!=( RefreshCycleDurationGOOGLE const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint64_t refreshDuration;
+  };
+  static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" );
+
+  struct RenderPassBeginInfo
+  {
+    RenderPassBeginInfo( RenderPass renderPass_ = RenderPass(),
+                         Framebuffer framebuffer_ = Framebuffer(),
+                         Rect2D renderArea_ = Rect2D(),
+                         uint32_t clearValueCount_ = 0,
+                         const ClearValue* pClearValues_ = nullptr )
+      : renderPass( renderPass_ )
+      , framebuffer( framebuffer_ )
+      , renderArea( renderArea_ )
+      , clearValueCount( clearValueCount_ )
+      , pClearValues( pClearValues_ )
+    {}
+
+    RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) );
+    }
+
+    RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) );
+      return *this;
+    }
+
+    RenderPassBeginInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    RenderPassBeginInfo & setRenderPass( RenderPass renderPass_ )
+    {
+      renderPass = renderPass_;
+      return *this;
+    }
+
+    RenderPassBeginInfo & setFramebuffer( Framebuffer framebuffer_ )
+    {
+      framebuffer = framebuffer_;
+      return *this;
+    }
+
+    RenderPassBeginInfo & setRenderArea( Rect2D renderArea_ )
+    {
+      renderArea = renderArea_;
+      return *this;
+    }
+
+    RenderPassBeginInfo & setClearValueCount( uint32_t clearValueCount_ )
+    {
+      clearValueCount = clearValueCount_;
+      return *this;
+    }
+
+    RenderPassBeginInfo & setPClearValues( const ClearValue* pClearValues_ )
+    {
+      pClearValues = pClearValues_;
+      return *this;
+    }
+
+    operator VkRenderPassBeginInfo const&() const
+    {
+      return *reinterpret_cast<const VkRenderPassBeginInfo*>( this );
+    }
+
+    operator VkRenderPassBeginInfo &()
+    {
+      return *reinterpret_cast<VkRenderPassBeginInfo*>( this );
+    }
+
+    bool operator==( RenderPassBeginInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( renderPass == rhs.renderPass )
+          && ( framebuffer == rhs.framebuffer )
+          && ( renderArea == rhs.renderArea )
+          && ( clearValueCount == rhs.clearValueCount )
+          && ( pClearValues == rhs.pClearValues );
+    }
+
+    bool operator!=( RenderPassBeginInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eRenderPassBeginInfo;
+
+  public:
+    const void* pNext = nullptr;
+    RenderPass renderPass;
+    Framebuffer framebuffer;
+    Rect2D renderArea;
+    uint32_t clearValueCount;
+    const ClearValue* pClearValues;
+  };
+  static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" );
 
   struct SubpassDescription
   {
@@ -35118,8 +41448,7 @@ public:
       , pDepthStencilAttachment( pDepthStencilAttachment_ )
       , preserveAttachmentCount( preserveAttachmentCount_ )
       , pPreserveAttachments( pPreserveAttachments_ )
-    {
-    }
+    {}
 
     SubpassDescription( VkSubpassDescription const & rhs )
     {
@@ -35131,61 +41460,62 @@ public:
       memcpy( this, &rhs, sizeof( SubpassDescription ) );
       return *this;
     }
-    SubpassDescription& setFlags( SubpassDescriptionFlags flags_ )
+
+    SubpassDescription & setFlags( SubpassDescriptionFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    SubpassDescription& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+    SubpassDescription & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
     {
       pipelineBindPoint = pipelineBindPoint_;
       return *this;
     }
 
-    SubpassDescription& setInputAttachmentCount( uint32_t inputAttachmentCount_ )
+    SubpassDescription & setInputAttachmentCount( uint32_t inputAttachmentCount_ )
     {
       inputAttachmentCount = inputAttachmentCount_;
       return *this;
     }
 
-    SubpassDescription& setPInputAttachments( const AttachmentReference* pInputAttachments_ )
+    SubpassDescription & setPInputAttachments( const AttachmentReference* pInputAttachments_ )
     {
       pInputAttachments = pInputAttachments_;
       return *this;
     }
 
-    SubpassDescription& setColorAttachmentCount( uint32_t colorAttachmentCount_ )
+    SubpassDescription & setColorAttachmentCount( uint32_t colorAttachmentCount_ )
     {
       colorAttachmentCount = colorAttachmentCount_;
       return *this;
     }
 
-    SubpassDescription& setPColorAttachments( const AttachmentReference* pColorAttachments_ )
+    SubpassDescription & setPColorAttachments( const AttachmentReference* pColorAttachments_ )
     {
       pColorAttachments = pColorAttachments_;
       return *this;
     }
 
-    SubpassDescription& setPResolveAttachments( const AttachmentReference* pResolveAttachments_ )
+    SubpassDescription & setPResolveAttachments( const AttachmentReference* pResolveAttachments_ )
     {
       pResolveAttachments = pResolveAttachments_;
       return *this;
     }
 
-    SubpassDescription& setPDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment_ )
+    SubpassDescription & setPDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment_ )
     {
       pDepthStencilAttachment = pDepthStencilAttachment_;
       return *this;
     }
 
-    SubpassDescription& setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ )
+    SubpassDescription & setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ )
     {
       preserveAttachmentCount = preserveAttachmentCount_;
       return *this;
     }
 
-    SubpassDescription& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ )
+    SubpassDescription & setPPreserveAttachments( const uint32_t* pPreserveAttachments_ )
     {
       pPreserveAttachments = pPreserveAttachments_;
       return *this;
@@ -35193,12 +41523,12 @@ public:
 
     operator VkSubpassDescription const&() const
     {
-      return *reinterpret_cast<const VkSubpassDescription*>(this);
+      return *reinterpret_cast<const VkSubpassDescription*>( this );
     }
 
     operator VkSubpassDescription &()
     {
-      return *reinterpret_cast<VkSubpassDescription*>(this);
+      return *reinterpret_cast<VkSubpassDescription*>( this );
     }
 
     bool operator==( SubpassDescription const& rhs ) const
@@ -35233,6 +41563,113 @@ public:
   };
   static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" );
 
+  struct SubpassDependency
+  {
+    SubpassDependency( uint32_t srcSubpass_ = 0,
+                       uint32_t dstSubpass_ = 0,
+                       PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
+                       PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
+                       AccessFlags srcAccessMask_ = AccessFlags(),
+                       AccessFlags dstAccessMask_ = AccessFlags(),
+                       DependencyFlags dependencyFlags_ = DependencyFlags() )
+      : srcSubpass( srcSubpass_ )
+      , dstSubpass( dstSubpass_ )
+      , srcStageMask( srcStageMask_ )
+      , dstStageMask( dstStageMask_ )
+      , srcAccessMask( srcAccessMask_ )
+      , dstAccessMask( dstAccessMask_ )
+      , dependencyFlags( dependencyFlags_ )
+    {}
+
+    SubpassDependency( VkSubpassDependency const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubpassDependency ) );
+    }
+
+    SubpassDependency& operator=( VkSubpassDependency const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubpassDependency ) );
+      return *this;
+    }
+
+    SubpassDependency & setSrcSubpass( uint32_t srcSubpass_ )
+    {
+      srcSubpass = srcSubpass_;
+      return *this;
+    }
+
+    SubpassDependency & setDstSubpass( uint32_t dstSubpass_ )
+    {
+      dstSubpass = dstSubpass_;
+      return *this;
+    }
+
+    SubpassDependency & setSrcStageMask( PipelineStageFlags srcStageMask_ )
+    {
+      srcStageMask = srcStageMask_;
+      return *this;
+    }
+
+    SubpassDependency & setDstStageMask( PipelineStageFlags dstStageMask_ )
+    {
+      dstStageMask = dstStageMask_;
+      return *this;
+    }
+
+    SubpassDependency & setSrcAccessMask( AccessFlags srcAccessMask_ )
+    {
+      srcAccessMask = srcAccessMask_;
+      return *this;
+    }
+
+    SubpassDependency & setDstAccessMask( AccessFlags dstAccessMask_ )
+    {
+      dstAccessMask = dstAccessMask_;
+      return *this;
+    }
+
+    SubpassDependency & setDependencyFlags( DependencyFlags dependencyFlags_ )
+    {
+      dependencyFlags = dependencyFlags_;
+      return *this;
+    }
+
+    operator VkSubpassDependency const&() const
+    {
+      return *reinterpret_cast<const VkSubpassDependency*>( this );
+    }
+
+    operator VkSubpassDependency &()
+    {
+      return *reinterpret_cast<VkSubpassDependency*>( this );
+    }
+
+    bool operator==( SubpassDependency const& rhs ) const
+    {
+      return ( srcSubpass == rhs.srcSubpass )
+          && ( dstSubpass == rhs.dstSubpass )
+          && ( srcStageMask == rhs.srcStageMask )
+          && ( dstStageMask == rhs.dstStageMask )
+          && ( srcAccessMask == rhs.srcAccessMask )
+          && ( dstAccessMask == rhs.dstAccessMask )
+          && ( dependencyFlags == rhs.dependencyFlags );
+    }
+
+    bool operator!=( SubpassDependency const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t srcSubpass;
+    uint32_t dstSubpass;
+    PipelineStageFlags srcStageMask;
+    PipelineStageFlags dstStageMask;
+    AccessFlags srcAccessMask;
+    AccessFlags dstAccessMask;
+    DependencyFlags dependencyFlags;
+  };
+  static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" );
+
   struct RenderPassCreateInfo
   {
     RenderPassCreateInfo( RenderPassCreateFlags flags_ = RenderPassCreateFlags(),
@@ -35249,8 +41686,7 @@ public:
       , pSubpasses( pSubpasses_ )
       , dependencyCount( dependencyCount_ )
       , pDependencies( pDependencies_ )
-    {
-    }
+    {}
 
     RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs )
     {
@@ -35262,49 +41698,50 @@ public:
       memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) );
       return *this;
     }
-    RenderPassCreateInfo& setPNext( const void* pNext_ )
+
+    RenderPassCreateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    RenderPassCreateInfo& setFlags( RenderPassCreateFlags flags_ )
+    RenderPassCreateInfo & setFlags( RenderPassCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    RenderPassCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
+    RenderPassCreateInfo & setAttachmentCount( uint32_t attachmentCount_ )
     {
       attachmentCount = attachmentCount_;
       return *this;
     }
 
-    RenderPassCreateInfo& setPAttachments( const AttachmentDescription* pAttachments_ )
+    RenderPassCreateInfo & setPAttachments( const AttachmentDescription* pAttachments_ )
     {
       pAttachments = pAttachments_;
       return *this;
     }
 
-    RenderPassCreateInfo& setSubpassCount( uint32_t subpassCount_ )
+    RenderPassCreateInfo & setSubpassCount( uint32_t subpassCount_ )
     {
       subpassCount = subpassCount_;
       return *this;
     }
 
-    RenderPassCreateInfo& setPSubpasses( const SubpassDescription* pSubpasses_ )
+    RenderPassCreateInfo & setPSubpasses( const SubpassDescription* pSubpasses_ )
     {
       pSubpasses = pSubpasses_;
       return *this;
     }
 
-    RenderPassCreateInfo& setDependencyCount( uint32_t dependencyCount_ )
+    RenderPassCreateInfo & setDependencyCount( uint32_t dependencyCount_ )
     {
       dependencyCount = dependencyCount_;
       return *this;
     }
 
-    RenderPassCreateInfo& setPDependencies( const SubpassDependency* pDependencies_ )
+    RenderPassCreateInfo & setPDependencies( const SubpassDependency* pDependencies_ )
     {
       pDependencies = pDependencies_;
       return *this;
@@ -35312,12 +41749,12 @@ public:
 
     operator VkRenderPassCreateInfo const&() const
     {
-      return *reinterpret_cast<const VkRenderPassCreateInfo*>(this);
+      return *reinterpret_cast<const VkRenderPassCreateInfo*>( this );
     }
 
     operator VkRenderPassCreateInfo &()
     {
-      return *reinterpret_cast<VkRenderPassCreateInfo*>(this);
+      return *reinterpret_cast<VkRenderPassCreateInfo*>( this );
     }
 
     bool operator==( RenderPassCreateInfo const& rhs ) const
@@ -35377,8 +41814,7 @@ public:
       , pDepthStencilAttachment( pDepthStencilAttachment_ )
       , preserveAttachmentCount( preserveAttachmentCount_ )
       , pPreserveAttachments( pPreserveAttachments_ )
-    {
-    }
+    {}
 
     SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs )
     {
@@ -35390,73 +41826,74 @@ public:
       memcpy( this, &rhs, sizeof( SubpassDescription2KHR ) );
       return *this;
     }
-    SubpassDescription2KHR& setPNext( const void* pNext_ )
+
+    SubpassDescription2KHR & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    SubpassDescription2KHR& setFlags( SubpassDescriptionFlags flags_ )
+    SubpassDescription2KHR & setFlags( SubpassDescriptionFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    SubpassDescription2KHR& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+    SubpassDescription2KHR & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
     {
       pipelineBindPoint = pipelineBindPoint_;
       return *this;
     }
 
-    SubpassDescription2KHR& setViewMask( uint32_t viewMask_ )
+    SubpassDescription2KHR & setViewMask( uint32_t viewMask_ )
     {
       viewMask = viewMask_;
       return *this;
     }
 
-    SubpassDescription2KHR& setInputAttachmentCount( uint32_t inputAttachmentCount_ )
+    SubpassDescription2KHR & setInputAttachmentCount( uint32_t inputAttachmentCount_ )
     {
       inputAttachmentCount = inputAttachmentCount_;
       return *this;
     }
 
-    SubpassDescription2KHR& setPInputAttachments( const AttachmentReference2KHR* pInputAttachments_ )
+    SubpassDescription2KHR & setPInputAttachments( const AttachmentReference2KHR* pInputAttachments_ )
     {
       pInputAttachments = pInputAttachments_;
       return *this;
     }
 
-    SubpassDescription2KHR& setColorAttachmentCount( uint32_t colorAttachmentCount_ )
+    SubpassDescription2KHR & setColorAttachmentCount( uint32_t colorAttachmentCount_ )
     {
       colorAttachmentCount = colorAttachmentCount_;
       return *this;
     }
 
-    SubpassDescription2KHR& setPColorAttachments( const AttachmentReference2KHR* pColorAttachments_ )
+    SubpassDescription2KHR & setPColorAttachments( const AttachmentReference2KHR* pColorAttachments_ )
     {
       pColorAttachments = pColorAttachments_;
       return *this;
     }
 
-    SubpassDescription2KHR& setPResolveAttachments( const AttachmentReference2KHR* pResolveAttachments_ )
+    SubpassDescription2KHR & setPResolveAttachments( const AttachmentReference2KHR* pResolveAttachments_ )
     {
       pResolveAttachments = pResolveAttachments_;
       return *this;
     }
 
-    SubpassDescription2KHR& setPDepthStencilAttachment( const AttachmentReference2KHR* pDepthStencilAttachment_ )
+    SubpassDescription2KHR & setPDepthStencilAttachment( const AttachmentReference2KHR* pDepthStencilAttachment_ )
     {
       pDepthStencilAttachment = pDepthStencilAttachment_;
       return *this;
     }
 
-    SubpassDescription2KHR& setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ )
+    SubpassDescription2KHR & setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ )
     {
       preserveAttachmentCount = preserveAttachmentCount_;
       return *this;
     }
 
-    SubpassDescription2KHR& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ )
+    SubpassDescription2KHR & setPPreserveAttachments( const uint32_t* pPreserveAttachments_ )
     {
       pPreserveAttachments = pPreserveAttachments_;
       return *this;
@@ -35464,12 +41901,12 @@ public:
 
     operator VkSubpassDescription2KHR const&() const
     {
-      return *reinterpret_cast<const VkSubpassDescription2KHR*>(this);
+      return *reinterpret_cast<const VkSubpassDescription2KHR*>( this );
     }
 
     operator VkSubpassDescription2KHR &()
     {
-      return *reinterpret_cast<VkSubpassDescription2KHR*>(this);
+      return *reinterpret_cast<VkSubpassDescription2KHR*>( this );
     }
 
     bool operator==( SubpassDescription2KHR const& rhs ) const
@@ -35513,6 +41950,136 @@ public:
   };
   static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "struct and wrapper have different size!" );
 
+  struct SubpassDependency2KHR
+  {
+    SubpassDependency2KHR( uint32_t srcSubpass_ = 0,
+                           uint32_t dstSubpass_ = 0,
+                           PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
+                           PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
+                           AccessFlags srcAccessMask_ = AccessFlags(),
+                           AccessFlags dstAccessMask_ = AccessFlags(),
+                           DependencyFlags dependencyFlags_ = DependencyFlags(),
+                           int32_t viewOffset_ = 0 )
+      : srcSubpass( srcSubpass_ )
+      , dstSubpass( dstSubpass_ )
+      , srcStageMask( srcStageMask_ )
+      , dstStageMask( dstStageMask_ )
+      , srcAccessMask( srcAccessMask_ )
+      , dstAccessMask( dstAccessMask_ )
+      , dependencyFlags( dependencyFlags_ )
+      , viewOffset( viewOffset_ )
+    {}
+
+    SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) );
+    }
+
+    SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) );
+      return *this;
+    }
+
+    SubpassDependency2KHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    SubpassDependency2KHR & setSrcSubpass( uint32_t srcSubpass_ )
+    {
+      srcSubpass = srcSubpass_;
+      return *this;
+    }
+
+    SubpassDependency2KHR & setDstSubpass( uint32_t dstSubpass_ )
+    {
+      dstSubpass = dstSubpass_;
+      return *this;
+    }
+
+    SubpassDependency2KHR & setSrcStageMask( PipelineStageFlags srcStageMask_ )
+    {
+      srcStageMask = srcStageMask_;
+      return *this;
+    }
+
+    SubpassDependency2KHR & setDstStageMask( PipelineStageFlags dstStageMask_ )
+    {
+      dstStageMask = dstStageMask_;
+      return *this;
+    }
+
+    SubpassDependency2KHR & setSrcAccessMask( AccessFlags srcAccessMask_ )
+    {
+      srcAccessMask = srcAccessMask_;
+      return *this;
+    }
+
+    SubpassDependency2KHR & setDstAccessMask( AccessFlags dstAccessMask_ )
+    {
+      dstAccessMask = dstAccessMask_;
+      return *this;
+    }
+
+    SubpassDependency2KHR & setDependencyFlags( DependencyFlags dependencyFlags_ )
+    {
+      dependencyFlags = dependencyFlags_;
+      return *this;
+    }
+
+    SubpassDependency2KHR & setViewOffset( int32_t viewOffset_ )
+    {
+      viewOffset = viewOffset_;
+      return *this;
+    }
+
+    operator VkSubpassDependency2KHR const&() const
+    {
+      return *reinterpret_cast<const VkSubpassDependency2KHR*>( this );
+    }
+
+    operator VkSubpassDependency2KHR &()
+    {
+      return *reinterpret_cast<VkSubpassDependency2KHR*>( this );
+    }
+
+    bool operator==( SubpassDependency2KHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( srcSubpass == rhs.srcSubpass )
+          && ( dstSubpass == rhs.dstSubpass )
+          && ( srcStageMask == rhs.srcStageMask )
+          && ( dstStageMask == rhs.dstStageMask )
+          && ( srcAccessMask == rhs.srcAccessMask )
+          && ( dstAccessMask == rhs.dstAccessMask )
+          && ( dependencyFlags == rhs.dependencyFlags )
+          && ( viewOffset == rhs.viewOffset );
+    }
+
+    bool operator!=( SubpassDependency2KHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSubpassDependency2KHR;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t srcSubpass;
+    uint32_t dstSubpass;
+    PipelineStageFlags srcStageMask;
+    PipelineStageFlags dstStageMask;
+    AccessFlags srcAccessMask;
+    AccessFlags dstAccessMask;
+    DependencyFlags dependencyFlags;
+    int32_t viewOffset;
+  };
+  static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "struct and wrapper have different size!" );
+
   struct RenderPassCreateInfo2KHR
   {
     RenderPassCreateInfo2KHR( RenderPassCreateFlags flags_ = RenderPassCreateFlags(),
@@ -35533,8 +42100,7 @@ public:
       , pDependencies( pDependencies_ )
       , correlatedViewMaskCount( correlatedViewMaskCount_ )
       , pCorrelatedViewMasks( pCorrelatedViewMasks_ )
-    {
-    }
+    {}
 
     RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs )
     {
@@ -35546,61 +42112,62 @@ public:
       memcpy( this, &rhs, sizeof( RenderPassCreateInfo2KHR ) );
       return *this;
     }
-    RenderPassCreateInfo2KHR& setPNext( const void* pNext_ )
+
+    RenderPassCreateInfo2KHR & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    RenderPassCreateInfo2KHR& setFlags( RenderPassCreateFlags flags_ )
+    RenderPassCreateInfo2KHR & setFlags( RenderPassCreateFlags flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    RenderPassCreateInfo2KHR& setAttachmentCount( uint32_t attachmentCount_ )
+    RenderPassCreateInfo2KHR & setAttachmentCount( uint32_t attachmentCount_ )
     {
       attachmentCount = attachmentCount_;
       return *this;
     }
 
-    RenderPassCreateInfo2KHR& setPAttachments( const AttachmentDescription2KHR* pAttachments_ )
+    RenderPassCreateInfo2KHR & setPAttachments( const AttachmentDescription2KHR* pAttachments_ )
     {
       pAttachments = pAttachments_;
       return *this;
     }
 
-    RenderPassCreateInfo2KHR& setSubpassCount( uint32_t subpassCount_ )
+    RenderPassCreateInfo2KHR & setSubpassCount( uint32_t subpassCount_ )
     {
       subpassCount = subpassCount_;
       return *this;
     }
 
-    RenderPassCreateInfo2KHR& setPSubpasses( const SubpassDescription2KHR* pSubpasses_ )
+    RenderPassCreateInfo2KHR & setPSubpasses( const SubpassDescription2KHR* pSubpasses_ )
     {
       pSubpasses = pSubpasses_;
       return *this;
     }
 
-    RenderPassCreateInfo2KHR& setDependencyCount( uint32_t dependencyCount_ )
+    RenderPassCreateInfo2KHR & setDependencyCount( uint32_t dependencyCount_ )
     {
       dependencyCount = dependencyCount_;
       return *this;
     }
 
-    RenderPassCreateInfo2KHR& setPDependencies( const SubpassDependency2KHR* pDependencies_ )
+    RenderPassCreateInfo2KHR & setPDependencies( const SubpassDependency2KHR* pDependencies_ )
     {
       pDependencies = pDependencies_;
       return *this;
     }
 
-    RenderPassCreateInfo2KHR& setCorrelatedViewMaskCount( uint32_t correlatedViewMaskCount_ )
+    RenderPassCreateInfo2KHR & setCorrelatedViewMaskCount( uint32_t correlatedViewMaskCount_ )
     {
       correlatedViewMaskCount = correlatedViewMaskCount_;
       return *this;
     }
 
-    RenderPassCreateInfo2KHR& setPCorrelatedViewMasks( const uint32_t* pCorrelatedViewMasks_ )
+    RenderPassCreateInfo2KHR & setPCorrelatedViewMasks( const uint32_t* pCorrelatedViewMasks_ )
     {
       pCorrelatedViewMasks = pCorrelatedViewMasks_;
       return *this;
@@ -35608,12 +42175,12 @@ public:
 
     operator VkRenderPassCreateInfo2KHR const&() const
     {
-      return *reinterpret_cast<const VkRenderPassCreateInfo2KHR*>(this);
+      return *reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( this );
     }
 
     operator VkRenderPassCreateInfo2KHR &()
     {
-      return *reinterpret_cast<VkRenderPassCreateInfo2KHR*>(this);
+      return *reinterpret_cast<VkRenderPassCreateInfo2KHR*>( this );
     }
 
     bool operator==( RenderPassCreateInfo2KHR const& rhs ) const
@@ -35653,62 +42220,608 @@ public:
   };
   static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "struct and wrapper have different size!" );
 
-  enum class PointClippingBehavior
+  struct RenderPassFragmentDensityMapCreateInfoEXT
   {
-    eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
-    eAllClipPlanesKHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
-    eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
-    eUserClipPlanesOnlyKHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY
-  };
+    RenderPassFragmentDensityMapCreateInfoEXT( AttachmentReference fragmentDensityMapAttachment_ = AttachmentReference() )
+      : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ )
+    {}
 
-  struct PhysicalDevicePointClippingProperties
-  {
-    operator VkPhysicalDevicePointClippingProperties const&() const
+    RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs )
     {
-      return *reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(this);
+      memcpy( this, &rhs, sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) );
     }
 
-    operator VkPhysicalDevicePointClippingProperties &()
+    RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs )
     {
-      return *reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(this);
+      memcpy( this, &rhs, sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) );
+      return *this;
     }
 
-    bool operator==( PhysicalDevicePointClippingProperties const& rhs ) const
+    RenderPassFragmentDensityMapCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    RenderPassFragmentDensityMapCreateInfoEXT & setFragmentDensityMapAttachment( AttachmentReference fragmentDensityMapAttachment_ )
+    {
+      fragmentDensityMapAttachment = fragmentDensityMapAttachment_;
+      return *this;
+    }
+
+    operator VkRenderPassFragmentDensityMapCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>( this );
+    }
+
+    operator VkRenderPassFragmentDensityMapCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>( this );
+    }
+
+    bool operator==( RenderPassFragmentDensityMapCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( pointClippingBehavior == rhs.pointClippingBehavior );
+          && ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment );
     }
 
-    bool operator!=( PhysicalDevicePointClippingProperties const& rhs ) const
+    bool operator!=( RenderPassFragmentDensityMapCreateInfoEXT const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePhysicalDevicePointClippingProperties;
+    StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT;
 
   public:
-    void* pNext = nullptr;
-    PointClippingBehavior pointClippingBehavior;
+    const void* pNext = nullptr;
+    AttachmentReference fragmentDensityMapAttachment;
   };
-  static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "struct and wrapper have different size!" );
+  static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "struct and wrapper have different size!" );
 
-  using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
-
-  enum class SamplerReductionModeEXT
+  struct RenderPassInputAttachmentAspectCreateInfo
   {
-    eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT,
-    eMin = VK_SAMPLER_REDUCTION_MODE_MIN_EXT,
-    eMax = VK_SAMPLER_REDUCTION_MODE_MAX_EXT
+    RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0,
+                                               const InputAttachmentAspectReference* pAspectReferences_ = nullptr )
+      : aspectReferenceCount( aspectReferenceCount_ )
+      , pAspectReferences( pAspectReferences_ )
+    {}
+
+    RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) );
+    }
+
+    RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) );
+      return *this;
+    }
+
+    RenderPassInputAttachmentAspectCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    RenderPassInputAttachmentAspectCreateInfo & setAspectReferenceCount( uint32_t aspectReferenceCount_ )
+    {
+      aspectReferenceCount = aspectReferenceCount_;
+      return *this;
+    }
+
+    RenderPassInputAttachmentAspectCreateInfo & setPAspectReferences( const InputAttachmentAspectReference* pAspectReferences_ )
+    {
+      pAspectReferences = pAspectReferences_;
+      return *this;
+    }
+
+    operator VkRenderPassInputAttachmentAspectCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>( this );
+    }
+
+    operator VkRenderPassInputAttachmentAspectCreateInfo &()
+    {
+      return *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>( this );
+    }
+
+    bool operator==( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( aspectReferenceCount == rhs.aspectReferenceCount )
+          && ( pAspectReferences == rhs.pAspectReferences );
+    }
+
+    bool operator!=( RenderPassInputAttachmentAspectCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t aspectReferenceCount;
+    const InputAttachmentAspectReference* pAspectReferences;
   };
+  static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" );
+
+  struct RenderPassMultiviewCreateInfo
+  {
+    RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0,
+                                   const uint32_t* pViewMasks_ = nullptr,
+                                   uint32_t dependencyCount_ = 0,
+                                   const int32_t* pViewOffsets_ = nullptr,
+                                   uint32_t correlationMaskCount_ = 0,
+                                   const uint32_t* pCorrelationMasks_ = nullptr )
+      : subpassCount( subpassCount_ )
+      , pViewMasks( pViewMasks_ )
+      , dependencyCount( dependencyCount_ )
+      , pViewOffsets( pViewOffsets_ )
+      , correlationMaskCount( correlationMaskCount_ )
+      , pCorrelationMasks( pCorrelationMasks_ )
+    {}
+
+    RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfo ) );
+    }
+
+    RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfo ) );
+      return *this;
+    }
+
+    RenderPassMultiviewCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    RenderPassMultiviewCreateInfo & setSubpassCount( uint32_t subpassCount_ )
+    {
+      subpassCount = subpassCount_;
+      return *this;
+    }
+
+    RenderPassMultiviewCreateInfo & setPViewMasks( const uint32_t* pViewMasks_ )
+    {
+      pViewMasks = pViewMasks_;
+      return *this;
+    }
+
+    RenderPassMultiviewCreateInfo & setDependencyCount( uint32_t dependencyCount_ )
+    {
+      dependencyCount = dependencyCount_;
+      return *this;
+    }
+
+    RenderPassMultiviewCreateInfo & setPViewOffsets( const int32_t* pViewOffsets_ )
+    {
+      pViewOffsets = pViewOffsets_;
+      return *this;
+    }
+
+    RenderPassMultiviewCreateInfo & setCorrelationMaskCount( uint32_t correlationMaskCount_ )
+    {
+      correlationMaskCount = correlationMaskCount_;
+      return *this;
+    }
+
+    RenderPassMultiviewCreateInfo & setPCorrelationMasks( const uint32_t* pCorrelationMasks_ )
+    {
+      pCorrelationMasks = pCorrelationMasks_;
+      return *this;
+    }
+
+    operator VkRenderPassMultiviewCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>( this );
+    }
+
+    operator VkRenderPassMultiviewCreateInfo &()
+    {
+      return *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>( this );
+    }
+
+    bool operator==( RenderPassMultiviewCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( subpassCount == rhs.subpassCount )
+          && ( pViewMasks == rhs.pViewMasks )
+          && ( dependencyCount == rhs.dependencyCount )
+          && ( pViewOffsets == rhs.pViewOffsets )
+          && ( correlationMaskCount == rhs.correlationMaskCount )
+          && ( pCorrelationMasks == rhs.pCorrelationMasks );
+    }
+
+    bool operator!=( RenderPassMultiviewCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eRenderPassMultiviewCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t subpassCount;
+    const uint32_t* pViewMasks;
+    uint32_t dependencyCount;
+    const int32_t* pViewOffsets;
+    uint32_t correlationMaskCount;
+    const uint32_t* pCorrelationMasks;
+  };
+  static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "struct and wrapper have different size!" );
+
+  struct SubpassSampleLocationsEXT
+  {
+    SubpassSampleLocationsEXT( uint32_t subpassIndex_ = 0,
+                               SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
+      : subpassIndex( subpassIndex_ )
+      , sampleLocationsInfo( sampleLocationsInfo_ )
+    {}
+
+    SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
+    }
+
+    SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
+      return *this;
+    }
+
+    SubpassSampleLocationsEXT & setSubpassIndex( uint32_t subpassIndex_ )
+    {
+      subpassIndex = subpassIndex_;
+      return *this;
+    }
+
+    SubpassSampleLocationsEXT & setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+    {
+      sampleLocationsInfo = sampleLocationsInfo_;
+      return *this;
+    }
+
+    operator VkSubpassSampleLocationsEXT const&() const
+    {
+      return *reinterpret_cast<const VkSubpassSampleLocationsEXT*>( this );
+    }
+
+    operator VkSubpassSampleLocationsEXT &()
+    {
+      return *reinterpret_cast<VkSubpassSampleLocationsEXT*>( this );
+    }
+
+    bool operator==( SubpassSampleLocationsEXT const& rhs ) const
+    {
+      return ( subpassIndex == rhs.subpassIndex )
+          && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+    }
+
+    bool operator!=( SubpassSampleLocationsEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t subpassIndex;
+    SampleLocationsInfoEXT sampleLocationsInfo;
+  };
+  static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" );
+
+  struct RenderPassSampleLocationsBeginInfoEXT
+  {
+    RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0,
+                                           const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr,
+                                           uint32_t postSubpassSampleLocationsCount_ = 0,
+                                           const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
+      : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
+      , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
+      , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
+      , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
+    {}
+
+    RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
+    }
+
+    RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
+      return *this;
+    }
+
+    RenderPassSampleLocationsBeginInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    RenderPassSampleLocationsBeginInfoEXT & setAttachmentInitialSampleLocationsCount( uint32_t attachmentInitialSampleLocationsCount_ )
+    {
+      attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_;
+      return *this;
+    }
+
+    RenderPassSampleLocationsBeginInfoEXT & setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ )
+    {
+      pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_;
+      return *this;
+    }
+
+    RenderPassSampleLocationsBeginInfoEXT & setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ )
+    {
+      postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_;
+      return *this;
+    }
+
+    RenderPassSampleLocationsBeginInfoEXT & setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ )
+    {
+      pPostSubpassSampleLocations = pPostSubpassSampleLocations_;
+      return *this;
+    }
+
+    operator VkRenderPassSampleLocationsBeginInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>( this );
+    }
+
+    operator VkRenderPassSampleLocationsBeginInfoEXT &()
+    {
+      return *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>( this );
+    }
+
+    bool operator==( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount )
+          && ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations )
+          && ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount )
+          && ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations );
+    }
+
+    bool operator!=( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t attachmentInitialSampleLocationsCount;
+    const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations;
+    uint32_t postSubpassSampleLocationsCount;
+    const SubpassSampleLocationsEXT* pPostSubpassSampleLocations;
+  };
+  static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" );
+
+  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 )
+      : flags( flags_ )
+      , magFilter( magFilter_ )
+      , minFilter( minFilter_ )
+      , mipmapMode( mipmapMode_ )
+      , addressModeU( addressModeU_ )
+      , addressModeV( addressModeV_ )
+      , addressModeW( addressModeW_ )
+      , mipLodBias( mipLodBias_ )
+      , anisotropyEnable( anisotropyEnable_ )
+      , maxAnisotropy( maxAnisotropy_ )
+      , compareEnable( compareEnable_ )
+      , compareOp( compareOp_ )
+      , minLod( minLod_ )
+      , maxLod( maxLod_ )
+      , borderColor( borderColor_ )
+      , unnormalizedCoordinates( unnormalizedCoordinates_ )
+    {}
+
+    SamplerCreateInfo( VkSamplerCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SamplerCreateInfo ) );
+    }
+
+    SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SamplerCreateInfo ) );
+      return *this;
+    }
+
+    SamplerCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setFlags( SamplerCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setMagFilter( Filter magFilter_ )
+    {
+      magFilter = magFilter_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setMinFilter( Filter minFilter_ )
+    {
+      minFilter = minFilter_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setMipmapMode( SamplerMipmapMode mipmapMode_ )
+    {
+      mipmapMode = mipmapMode_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setAddressModeU( SamplerAddressMode addressModeU_ )
+    {
+      addressModeU = addressModeU_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setAddressModeV( SamplerAddressMode addressModeV_ )
+    {
+      addressModeV = addressModeV_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setAddressModeW( SamplerAddressMode addressModeW_ )
+    {
+      addressModeW = addressModeW_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setMipLodBias( float mipLodBias_ )
+    {
+      mipLodBias = mipLodBias_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setAnisotropyEnable( Bool32 anisotropyEnable_ )
+    {
+      anisotropyEnable = anisotropyEnable_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setMaxAnisotropy( float maxAnisotropy_ )
+    {
+      maxAnisotropy = maxAnisotropy_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setCompareEnable( Bool32 compareEnable_ )
+    {
+      compareEnable = compareEnable_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setCompareOp( CompareOp compareOp_ )
+    {
+      compareOp = compareOp_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setMinLod( float minLod_ )
+    {
+      minLod = minLod_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setMaxLod( float maxLod_ )
+    {
+      maxLod = maxLod_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setBorderColor( BorderColor borderColor_ )
+    {
+      borderColor = borderColor_;
+      return *this;
+    }
+
+    SamplerCreateInfo & setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ )
+    {
+      unnormalizedCoordinates = unnormalizedCoordinates_;
+      return *this;
+    }
+
+    operator VkSamplerCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkSamplerCreateInfo*>( this );
+    }
+
+    operator VkSamplerCreateInfo &()
+    {
+      return *reinterpret_cast<VkSamplerCreateInfo*>( this );
+    }
+
+    bool operator==( SamplerCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( magFilter == rhs.magFilter )
+          && ( minFilter == rhs.minFilter )
+          && ( mipmapMode == rhs.mipmapMode )
+          && ( addressModeU == rhs.addressModeU )
+          && ( addressModeV == rhs.addressModeV )
+          && ( addressModeW == rhs.addressModeW )
+          && ( mipLodBias == rhs.mipLodBias )
+          && ( anisotropyEnable == rhs.anisotropyEnable )
+          && ( maxAnisotropy == rhs.maxAnisotropy )
+          && ( compareEnable == rhs.compareEnable )
+          && ( compareOp == rhs.compareOp )
+          && ( minLod == rhs.minLod )
+          && ( maxLod == rhs.maxLod )
+          && ( borderColor == rhs.borderColor )
+          && ( unnormalizedCoordinates == rhs.unnormalizedCoordinates );
+    }
+
+    bool operator!=( SamplerCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSamplerCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    SamplerCreateFlags flags;
+    Filter magFilter;
+    Filter minFilter;
+    SamplerMipmapMode mipmapMode;
+    SamplerAddressMode addressModeU;
+    SamplerAddressMode addressModeV;
+    SamplerAddressMode addressModeW;
+    float mipLodBias;
+    Bool32 anisotropyEnable;
+    float maxAnisotropy;
+    Bool32 compareEnable;
+    CompareOp compareOp;
+    float minLod;
+    float maxLod;
+    BorderColor borderColor;
+    Bool32 unnormalizedCoordinates;
+  };
+  static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" );
 
   struct SamplerReductionModeCreateInfoEXT
   {
     SamplerReductionModeCreateInfoEXT( SamplerReductionModeEXT reductionMode_ = SamplerReductionModeEXT::eWeightedAverage )
       : reductionMode( reductionMode_ )
-    {
-    }
+    {}
 
     SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs )
     {
@@ -35720,13 +42833,14 @@ public:
       memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) );
       return *this;
     }
-    SamplerReductionModeCreateInfoEXT& setPNext( const void* pNext_ )
+
+    SamplerReductionModeCreateInfoEXT & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    SamplerReductionModeCreateInfoEXT& setReductionMode( SamplerReductionModeEXT reductionMode_ )
+    SamplerReductionModeCreateInfoEXT & setReductionMode( SamplerReductionModeEXT reductionMode_ )
     {
       reductionMode = reductionMode_;
       return *this;
@@ -35734,12 +42848,12 @@ public:
 
     operator VkSamplerReductionModeCreateInfoEXT const&() const
     {
-      return *reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT*>(this);
+      return *reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT*>( this );
     }
 
     operator VkSamplerReductionModeCreateInfoEXT &()
     {
-      return *reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(this);
+      return *reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>( this );
     }
 
     bool operator==( SamplerReductionModeCreateInfoEXT const& rhs ) const
@@ -35763,106 +42877,6 @@ public:
   };
   static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" );
 
-  enum class TessellationDomainOrigin
-  {
-    eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
-    eUpperLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
-    eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
-    eLowerLeftKHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT
-  };
-
-  struct PipelineTessellationDomainOriginStateCreateInfo
-  {
-    PipelineTessellationDomainOriginStateCreateInfo( TessellationDomainOrigin domainOrigin_ = TessellationDomainOrigin::eUpperLeft )
-      : domainOrigin( domainOrigin_ )
-    {
-    }
-
-    PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) );
-    }
-
-    PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) );
-      return *this;
-    }
-    PipelineTessellationDomainOriginStateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineTessellationDomainOriginStateCreateInfo& setDomainOrigin( TessellationDomainOrigin domainOrigin_ )
-    {
-      domainOrigin = domainOrigin_;
-      return *this;
-    }
-
-    operator VkPipelineTessellationDomainOriginStateCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(this);
-    }
-
-    operator VkPipelineTessellationDomainOriginStateCreateInfo &()
-    {
-      return *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( domainOrigin == rhs.domainOrigin );
-    }
-
-    bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    TessellationDomainOrigin domainOrigin;
-  };
-  static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "struct and wrapper have different size!" );
-
-  using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
-
-  enum class SamplerYcbcrModelConversion
-  {
-    eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
-    eRgbIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
-    eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
-    eYcbcrIdentityKHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
-    eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
-    eYcbcr709KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
-    eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
-    eYcbcr601KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
-    eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
-    eYcbcr2020KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020
-  };
-
-  enum class SamplerYcbcrRange
-  {
-    eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
-    eItuFullKHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
-    eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
-    eItuNarrowKHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW
-  };
-
-  enum class ChromaLocation
-  {
-    eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN,
-    eCositedEvenKHR = VK_CHROMA_LOCATION_COSITED_EVEN,
-    eMidpoint = VK_CHROMA_LOCATION_MIDPOINT,
-    eMidpointKHR = VK_CHROMA_LOCATION_MIDPOINT
-  };
-
   struct SamplerYcbcrConversionCreateInfo
   {
     SamplerYcbcrConversionCreateInfo( Format format_ = Format::eUndefined,
@@ -35881,8 +42895,7 @@ public:
       , yChromaOffset( yChromaOffset_ )
       , chromaFilter( chromaFilter_ )
       , forceExplicitReconstruction( forceExplicitReconstruction_ )
-    {
-    }
+    {}
 
     SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs )
     {
@@ -35894,55 +42907,56 @@ public:
       memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) );
       return *this;
     }
-    SamplerYcbcrConversionCreateInfo& setPNext( const void* pNext_ )
+
+    SamplerYcbcrConversionCreateInfo & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo& setFormat( Format format_ )
+    SamplerYcbcrConversionCreateInfo & setFormat( Format format_ )
     {
       format = format_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo& setYcbcrModel( SamplerYcbcrModelConversion ycbcrModel_ )
+    SamplerYcbcrConversionCreateInfo & setYcbcrModel( SamplerYcbcrModelConversion ycbcrModel_ )
     {
       ycbcrModel = ycbcrModel_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo& setYcbcrRange( SamplerYcbcrRange ycbcrRange_ )
+    SamplerYcbcrConversionCreateInfo & setYcbcrRange( SamplerYcbcrRange ycbcrRange_ )
     {
       ycbcrRange = ycbcrRange_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo& setComponents( ComponentMapping components_ )
+    SamplerYcbcrConversionCreateInfo & setComponents( ComponentMapping components_ )
     {
       components = components_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo& setXChromaOffset( ChromaLocation xChromaOffset_ )
+    SamplerYcbcrConversionCreateInfo & setXChromaOffset( ChromaLocation xChromaOffset_ )
     {
       xChromaOffset = xChromaOffset_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo& setYChromaOffset( ChromaLocation yChromaOffset_ )
+    SamplerYcbcrConversionCreateInfo & setYChromaOffset( ChromaLocation yChromaOffset_ )
     {
       yChromaOffset = yChromaOffset_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo& setChromaFilter( Filter chromaFilter_ )
+    SamplerYcbcrConversionCreateInfo & setChromaFilter( Filter chromaFilter_ )
     {
       chromaFilter = chromaFilter_;
       return *this;
     }
 
-    SamplerYcbcrConversionCreateInfo& setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ )
+    SamplerYcbcrConversionCreateInfo & setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ )
     {
       forceExplicitReconstruction = forceExplicitReconstruction_;
       return *this;
@@ -35950,12 +42964,12 @@ public:
 
     operator VkSamplerYcbcrConversionCreateInfo const&() const
     {
-      return *reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>(this);
+      return *reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( this );
     }
 
     operator VkSamplerYcbcrConversionCreateInfo &()
     {
-      return *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>(this);
+      return *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>( this );
     }
 
     bool operator==( SamplerYcbcrConversionCreateInfo const& rhs ) const
@@ -35993,1989 +43007,2489 @@ public:
   };
   static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "struct and wrapper have different size!" );
 
-  using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct AndroidHardwareBufferFormatPropertiesANDROID
+  struct SamplerYcbcrConversionImageFormatProperties
   {
-    operator VkAndroidHardwareBufferFormatPropertiesANDROID const&() const
+    operator VkSamplerYcbcrConversionImageFormatProperties const&() const
     {
-      return *reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(this);
+      return *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>( this );
     }
 
-    operator VkAndroidHardwareBufferFormatPropertiesANDROID &()
+    operator VkSamplerYcbcrConversionImageFormatProperties &()
     {
-      return *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(this);
+      return *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>( this );
     }
 
-    bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const
+    bool operator==( SamplerYcbcrConversionImageFormatProperties const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( format == rhs.format )
-          && ( externalFormat == rhs.externalFormat )
-          && ( formatFeatures == rhs.formatFeatures )
-          && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents )
-          && ( suggestedYcbcrModel == rhs.suggestedYcbcrModel )
-          && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange )
-          && ( suggestedXChromaOffset == rhs.suggestedXChromaOffset )
-          && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
+          && ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount );
     }
 
-    bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const
+    bool operator!=( SamplerYcbcrConversionImageFormatProperties const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID;
+    StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties;
 
   public:
     void* pNext = nullptr;
+    uint32_t combinedImageSamplerDescriptorCount;
+  };
+  static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "struct and wrapper have different size!" );
+
+  struct SamplerYcbcrConversionInfo
+  {
+    SamplerYcbcrConversionInfo( SamplerYcbcrConversion conversion_ = SamplerYcbcrConversion() )
+      : conversion( conversion_ )
+    {}
+
+    SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfo ) );
+    }
+
+    SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfo ) );
+      return *this;
+    }
+
+    SamplerYcbcrConversionInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    SamplerYcbcrConversionInfo & setConversion( SamplerYcbcrConversion conversion_ )
+    {
+      conversion = conversion_;
+      return *this;
+    }
+
+    operator VkSamplerYcbcrConversionInfo const&() const
+    {
+      return *reinterpret_cast<const VkSamplerYcbcrConversionInfo*>( this );
+    }
+
+    operator VkSamplerYcbcrConversionInfo &()
+    {
+      return *reinterpret_cast<VkSamplerYcbcrConversionInfo*>( this );
+    }
+
+    bool operator==( SamplerYcbcrConversionInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( conversion == rhs.conversion );
+    }
+
+    bool operator!=( SamplerYcbcrConversionInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSamplerYcbcrConversionInfo;
+
+  public:
+    const void* pNext = nullptr;
+    SamplerYcbcrConversion conversion;
+  };
+  static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "struct and wrapper have different size!" );
+
+  struct SemaphoreCreateInfo
+  {
+    SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = SemaphoreCreateFlags() )
+      : flags( flags_ )
+    {}
+
+    SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) );
+    }
+
+    SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) );
+      return *this;
+    }
+
+    SemaphoreCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    SemaphoreCreateInfo & setFlags( SemaphoreCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    operator VkSemaphoreCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkSemaphoreCreateInfo*>( this );
+    }
+
+    operator VkSemaphoreCreateInfo &()
+    {
+      return *reinterpret_cast<VkSemaphoreCreateInfo*>( this );
+    }
+
+    bool operator==( SemaphoreCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags );
+    }
+
+    bool operator!=( SemaphoreCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSemaphoreCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    SemaphoreCreateFlags flags;
+  };
+  static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" );
+
+  struct SemaphoreGetFdInfoKHR
+  {
+    SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(),
+                           ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+      : semaphore( semaphore_ )
+      , handleType( handleType_ )
+    {}
+
+    SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
+    }
+
+    SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
+      return *this;
+    }
+
+    SemaphoreGetFdInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    SemaphoreGetFdInfoKHR & setSemaphore( Semaphore semaphore_ )
+    {
+      semaphore = semaphore_;
+      return *this;
+    }
+
+    SemaphoreGetFdInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    operator VkSemaphoreGetFdInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( this );
+    }
+
+    operator VkSemaphoreGetFdInfoKHR &()
+    {
+      return *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>( this );
+    }
+
+    bool operator==( SemaphoreGetFdInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( semaphore == rhs.semaphore )
+          && ( handleType == rhs.handleType );
+    }
+
+    bool operator!=( SemaphoreGetFdInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSemaphoreGetFdInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    Semaphore semaphore;
+    ExternalSemaphoreHandleTypeFlagBits handleType;
+  };
+  static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct SemaphoreGetWin32HandleInfoKHR
+  {
+    SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
+                                    ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+      : semaphore( semaphore_ )
+      , handleType( handleType_ )
+    {}
+
+    SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
+    }
+
+    SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
+      return *this;
+    }
+
+    SemaphoreGetWin32HandleInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    SemaphoreGetWin32HandleInfoKHR & setSemaphore( Semaphore semaphore_ )
+    {
+      semaphore = semaphore_;
+      return *this;
+    }
+
+    SemaphoreGetWin32HandleInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+    {
+      handleType = handleType_;
+      return *this;
+    }
+
+    operator VkSemaphoreGetWin32HandleInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( this );
+    }
+
+    operator VkSemaphoreGetWin32HandleInfoKHR &()
+    {
+      return *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>( this );
+    }
+
+    bool operator==( SemaphoreGetWin32HandleInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( semaphore == rhs.semaphore )
+          && ( handleType == rhs.handleType );
+    }
+
+    bool operator!=( SemaphoreGetWin32HandleInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    Semaphore semaphore;
+    ExternalSemaphoreHandleTypeFlagBits handleType;
+  };
+  static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  struct ShaderModuleCreateInfo
+  {
+    ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = ShaderModuleCreateFlags(),
+                            size_t codeSize_ = 0,
+                            const uint32_t* pCode_ = nullptr )
+      : flags( flags_ )
+      , codeSize( codeSize_ )
+      , pCode( pCode_ )
+    {}
+
+    ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) );
+    }
+
+    ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) );
+      return *this;
+    }
+
+    ShaderModuleCreateInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ShaderModuleCreateInfo & setFlags( ShaderModuleCreateFlags flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ShaderModuleCreateInfo & setCodeSize( size_t codeSize_ )
+    {
+      codeSize = codeSize_;
+      return *this;
+    }
+
+    ShaderModuleCreateInfo & setPCode( const uint32_t* pCode_ )
+    {
+      pCode = pCode_;
+      return *this;
+    }
+
+    operator VkShaderModuleCreateInfo const&() const
+    {
+      return *reinterpret_cast<const VkShaderModuleCreateInfo*>( this );
+    }
+
+    operator VkShaderModuleCreateInfo &()
+    {
+      return *reinterpret_cast<VkShaderModuleCreateInfo*>( this );
+    }
+
+    bool operator==( ShaderModuleCreateInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( codeSize == rhs.codeSize )
+          && ( pCode == rhs.pCode );
+    }
+
+    bool operator!=( ShaderModuleCreateInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eShaderModuleCreateInfo;
+
+  public:
+    const void* pNext = nullptr;
+    ShaderModuleCreateFlags flags;
+    size_t codeSize;
+    const uint32_t* pCode;
+  };
+  static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "struct and wrapper have different size!" );
+
+  struct ShaderModuleValidationCacheCreateInfoEXT
+  {
+    ShaderModuleValidationCacheCreateInfoEXT( ValidationCacheEXT validationCache_ = ValidationCacheEXT() )
+      : validationCache( validationCache_ )
+    {}
+
+    ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) );
+    }
+
+    ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) );
+      return *this;
+    }
+
+    ShaderModuleValidationCacheCreateInfoEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ShaderModuleValidationCacheCreateInfoEXT & setValidationCache( ValidationCacheEXT validationCache_ )
+    {
+      validationCache = validationCache_;
+      return *this;
+    }
+
+    operator VkShaderModuleValidationCacheCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>( this );
+    }
+
+    operator VkShaderModuleValidationCacheCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>( this );
+    }
+
+    bool operator==( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( validationCache == rhs.validationCache );
+    }
+
+    bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT;
+
+  public:
+    const void* pNext = nullptr;
+    ValidationCacheEXT validationCache;
+  };
+  static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
+
+  struct ShaderResourceUsageAMD
+  {
+    operator VkShaderResourceUsageAMD const&() const
+    {
+      return *reinterpret_cast<const VkShaderResourceUsageAMD*>( this );
+    }
+
+    operator VkShaderResourceUsageAMD &()
+    {
+      return *reinterpret_cast<VkShaderResourceUsageAMD*>( this );
+    }
+
+    bool operator==( ShaderResourceUsageAMD const& rhs ) const
+    {
+      return ( numUsedVgprs == rhs.numUsedVgprs )
+          && ( numUsedSgprs == rhs.numUsedSgprs )
+          && ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup )
+          && ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes )
+          && ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes );
+    }
+
+    bool operator!=( ShaderResourceUsageAMD const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t numUsedVgprs;
+    uint32_t numUsedSgprs;
+    uint32_t ldsSizePerLocalWorkGroup;
+    size_t ldsUsageSizeInBytes;
+    size_t scratchMemUsageInBytes;
+  };
+  static_assert( sizeof( ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), "struct and wrapper have different size!" );
+
+  struct ShaderStatisticsInfoAMD
+  {
+    operator VkShaderStatisticsInfoAMD const&() const
+    {
+      return *reinterpret_cast<const VkShaderStatisticsInfoAMD*>( this );
+    }
+
+    operator VkShaderStatisticsInfoAMD &()
+    {
+      return *reinterpret_cast<VkShaderStatisticsInfoAMD*>( this );
+    }
+
+    bool operator==( ShaderStatisticsInfoAMD const& rhs ) const
+    {
+      return ( shaderStageMask == rhs.shaderStageMask )
+          && ( resourceUsage == rhs.resourceUsage )
+          && ( numPhysicalVgprs == rhs.numPhysicalVgprs )
+          && ( numPhysicalSgprs == rhs.numPhysicalSgprs )
+          && ( numAvailableVgprs == rhs.numAvailableVgprs )
+          && ( numAvailableSgprs == rhs.numAvailableSgprs )
+          && ( memcmp( computeWorkGroupSize, rhs.computeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 );
+    }
+
+    bool operator!=( ShaderStatisticsInfoAMD const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ShaderStageFlags shaderStageMask;
+    ShaderResourceUsageAMD resourceUsage;
+    uint32_t numPhysicalVgprs;
+    uint32_t numPhysicalSgprs;
+    uint32_t numAvailableVgprs;
+    uint32_t numAvailableSgprs;
+    uint32_t computeWorkGroupSize[3];
+  };
+  static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" );
+
+  struct SharedPresentSurfaceCapabilitiesKHR
+  {
+    operator VkSharedPresentSurfaceCapabilitiesKHR const&() const
+    {
+      return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>( this );
+    }
+
+    operator VkSharedPresentSurfaceCapabilitiesKHR &()
+    {
+      return *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>( this );
+    }
+
+    bool operator==( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags );
+    }
+
+    bool operator!=( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
+
+  public:
+    void* pNext = nullptr;
+    ImageUsageFlags sharedPresentSupportedUsageFlags;
+  };
+  static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
+
+  struct SparseImageFormatProperties
+  {
+    operator VkSparseImageFormatProperties const&() const
+    {
+      return *reinterpret_cast<const VkSparseImageFormatProperties*>( this );
+    }
+
+    operator VkSparseImageFormatProperties &()
+    {
+      return *reinterpret_cast<VkSparseImageFormatProperties*>( this );
+    }
+
+    bool operator==( SparseImageFormatProperties const& rhs ) const
+    {
+      return ( aspectMask == rhs.aspectMask )
+          && ( imageGranularity == rhs.imageGranularity )
+          && ( flags == rhs.flags );
+    }
+
+    bool operator!=( SparseImageFormatProperties const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    ImageAspectFlags aspectMask;
+    Extent3D imageGranularity;
+    SparseImageFormatFlags flags;
+  };
+  static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" );
+
+  struct SparseImageFormatProperties2
+  {
+    operator VkSparseImageFormatProperties2 const&() const
+    {
+      return *reinterpret_cast<const VkSparseImageFormatProperties2*>( this );
+    }
+
+    operator VkSparseImageFormatProperties2 &()
+    {
+      return *reinterpret_cast<VkSparseImageFormatProperties2*>( this );
+    }
+
+    bool operator==( SparseImageFormatProperties2 const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( properties == rhs.properties );
+    }
+
+    bool operator!=( SparseImageFormatProperties2 const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSparseImageFormatProperties2;
+
+  public:
+    void* pNext = nullptr;
+    SparseImageFormatProperties properties;
+  };
+  static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "struct and wrapper have different size!" );
+
+  struct SparseImageMemoryRequirements
+  {
+    operator VkSparseImageMemoryRequirements const&() const
+    {
+      return *reinterpret_cast<const VkSparseImageMemoryRequirements*>( this );
+    }
+
+    operator VkSparseImageMemoryRequirements &()
+    {
+      return *reinterpret_cast<VkSparseImageMemoryRequirements*>( this );
+    }
+
+    bool operator==( SparseImageMemoryRequirements const& rhs ) const
+    {
+      return ( formatProperties == rhs.formatProperties )
+          && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod )
+          && ( imageMipTailSize == rhs.imageMipTailSize )
+          && ( imageMipTailOffset == rhs.imageMipTailOffset )
+          && ( imageMipTailStride == rhs.imageMipTailStride );
+    }
+
+    bool operator!=( SparseImageMemoryRequirements const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    SparseImageFormatProperties formatProperties;
+    uint32_t imageMipTailFirstLod;
+    DeviceSize imageMipTailSize;
+    DeviceSize imageMipTailOffset;
+    DeviceSize imageMipTailStride;
+  };
+  static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" );
+
+  struct SparseImageMemoryRequirements2
+  {
+    operator VkSparseImageMemoryRequirements2 const&() const
+    {
+      return *reinterpret_cast<const VkSparseImageMemoryRequirements2*>( this );
+    }
+
+    operator VkSparseImageMemoryRequirements2 &()
+    {
+      return *reinterpret_cast<VkSparseImageMemoryRequirements2*>( this );
+    }
+
+    bool operator==( SparseImageMemoryRequirements2 const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( memoryRequirements == rhs.memoryRequirements );
+    }
+
+    bool operator!=( SparseImageMemoryRequirements2 const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSparseImageMemoryRequirements2;
+
+  public:
+    void* pNext = nullptr;
+    SparseImageMemoryRequirements memoryRequirements;
+  };
+  static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" );
+
+  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 )
+      : waitSemaphoreCount( waitSemaphoreCount_ )
+      , pWaitSemaphores( pWaitSemaphores_ )
+      , pWaitDstStageMask( pWaitDstStageMask_ )
+      , commandBufferCount( commandBufferCount_ )
+      , pCommandBuffers( pCommandBuffers_ )
+      , signalSemaphoreCount( signalSemaphoreCount_ )
+      , pSignalSemaphores( pSignalSemaphores_ )
+    {}
+
+    SubmitInfo( VkSubmitInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubmitInfo ) );
+    }
+
+    SubmitInfo& operator=( VkSubmitInfo const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubmitInfo ) );
+      return *this;
+    }
+
+    SubmitInfo & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    SubmitInfo & setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
+    {
+      waitSemaphoreCount = waitSemaphoreCount_;
+      return *this;
+    }
+
+    SubmitInfo & setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+    {
+      pWaitSemaphores = pWaitSemaphores_;
+      return *this;
+    }
+
+    SubmitInfo & setPWaitDstStageMask( const PipelineStageFlags* pWaitDstStageMask_ )
+    {
+      pWaitDstStageMask = pWaitDstStageMask_;
+      return *this;
+    }
+
+    SubmitInfo & setCommandBufferCount( uint32_t commandBufferCount_ )
+    {
+      commandBufferCount = commandBufferCount_;
+      return *this;
+    }
+
+    SubmitInfo & setPCommandBuffers( const CommandBuffer* pCommandBuffers_ )
+    {
+      pCommandBuffers = pCommandBuffers_;
+      return *this;
+    }
+
+    SubmitInfo & setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
+    {
+      signalSemaphoreCount = signalSemaphoreCount_;
+      return *this;
+    }
+
+    SubmitInfo & setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
+    {
+      pSignalSemaphores = pSignalSemaphores_;
+      return *this;
+    }
+
+    operator VkSubmitInfo const&() const
+    {
+      return *reinterpret_cast<const VkSubmitInfo*>( this );
+    }
+
+    operator VkSubmitInfo &()
+    {
+      return *reinterpret_cast<VkSubmitInfo*>( this );
+    }
+
+    bool operator==( SubmitInfo const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
+          && ( pWaitSemaphores == rhs.pWaitSemaphores )
+          && ( pWaitDstStageMask == rhs.pWaitDstStageMask )
+          && ( commandBufferCount == rhs.commandBufferCount )
+          && ( pCommandBuffers == rhs.pCommandBuffers )
+          && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
+          && ( pSignalSemaphores == rhs.pSignalSemaphores );
+    }
+
+    bool operator!=( SubmitInfo const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSubmitInfo;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t waitSemaphoreCount;
+    const Semaphore* pWaitSemaphores;
+    const PipelineStageFlags* pWaitDstStageMask;
+    uint32_t commandBufferCount;
+    const CommandBuffer* pCommandBuffers;
+    uint32_t signalSemaphoreCount;
+    const Semaphore* pSignalSemaphores;
+  };
+  static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" );
+
+  struct SubpassBeginInfoKHR
+  {
+    SubpassBeginInfoKHR( SubpassContents contents_ = SubpassContents::eInline )
+      : contents( contents_ )
+    {}
+
+    SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
+    }
+
+    SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
+      return *this;
+    }
+
+    SubpassBeginInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    SubpassBeginInfoKHR & setContents( SubpassContents contents_ )
+    {
+      contents = contents_;
+      return *this;
+    }
+
+    operator VkSubpassBeginInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkSubpassBeginInfoKHR*>( this );
+    }
+
+    operator VkSubpassBeginInfoKHR &()
+    {
+      return *reinterpret_cast<VkSubpassBeginInfoKHR*>( this );
+    }
+
+    bool operator==( SubpassBeginInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( contents == rhs.contents );
+    }
+
+    bool operator!=( SubpassBeginInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSubpassBeginInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    SubpassContents contents;
+  };
+  static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "struct and wrapper have different size!" );
+
+  struct SubpassEndInfoKHR
+  {
+    SubpassEndInfoKHR(  )
+    {}
+
+    SubpassEndInfoKHR( VkSubpassEndInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubpassEndInfoKHR ) );
+    }
+
+    SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( SubpassEndInfoKHR ) );
+      return *this;
+    }
+
+    SubpassEndInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    operator VkSubpassEndInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkSubpassEndInfoKHR*>( this );
+    }
+
+    operator VkSubpassEndInfoKHR &()
+    {
+      return *reinterpret_cast<VkSubpassEndInfoKHR*>( this );
+    }
+
+    bool operator==( SubpassEndInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext );
+    }
+
+    bool operator!=( SubpassEndInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSubpassEndInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+  };
+  static_assert( sizeof( SubpassEndInfoKHR ) == sizeof( VkSubpassEndInfoKHR ), "struct and wrapper have different size!" );
+
+  struct SurfaceCapabilities2EXT
+  {
+    operator VkSurfaceCapabilities2EXT const&() const
+    {
+      return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>( this );
+    }
+
+    operator VkSurfaceCapabilities2EXT &()
+    {
+      return *reinterpret_cast<VkSurfaceCapabilities2EXT*>( this );
+    }
+
+    bool operator==( SurfaceCapabilities2EXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( minImageCount == rhs.minImageCount )
+          && ( maxImageCount == rhs.maxImageCount )
+          && ( currentExtent == rhs.currentExtent )
+          && ( minImageExtent == rhs.minImageExtent )
+          && ( maxImageExtent == rhs.maxImageExtent )
+          && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
+          && ( supportedTransforms == rhs.supportedTransforms )
+          && ( currentTransform == rhs.currentTransform )
+          && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
+          && ( supportedUsageFlags == rhs.supportedUsageFlags )
+          && ( supportedSurfaceCounters == rhs.supportedSurfaceCounters );
+    }
+
+    bool operator!=( SurfaceCapabilities2EXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSurfaceCapabilities2EXT;
+
+  public:
+    void* pNext = nullptr;
+    uint32_t minImageCount;
+    uint32_t maxImageCount;
+    Extent2D currentExtent;
+    Extent2D minImageExtent;
+    Extent2D maxImageExtent;
+    uint32_t maxImageArrayLayers;
+    SurfaceTransformFlagsKHR supportedTransforms;
+    SurfaceTransformFlagBitsKHR currentTransform;
+    CompositeAlphaFlagsKHR supportedCompositeAlpha;
+    ImageUsageFlags supportedUsageFlags;
+    SurfaceCounterFlagsEXT supportedSurfaceCounters;
+  };
+  static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" );
+
+  struct SurfaceCapabilitiesKHR
+  {
+    operator VkSurfaceCapabilitiesKHR const&() const
+    {
+      return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>( this );
+    }
+
+    operator VkSurfaceCapabilitiesKHR &()
+    {
+      return *reinterpret_cast<VkSurfaceCapabilitiesKHR*>( this );
+    }
+
+    bool operator==( SurfaceCapabilitiesKHR const& rhs ) const
+    {
+      return ( minImageCount == rhs.minImageCount )
+          && ( maxImageCount == rhs.maxImageCount )
+          && ( currentExtent == rhs.currentExtent )
+          && ( minImageExtent == rhs.minImageExtent )
+          && ( maxImageExtent == rhs.maxImageExtent )
+          && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
+          && ( supportedTransforms == rhs.supportedTransforms )
+          && ( currentTransform == rhs.currentTransform )
+          && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
+          && ( supportedUsageFlags == rhs.supportedUsageFlags );
+    }
+
+    bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+    uint32_t minImageCount;
+    uint32_t maxImageCount;
+    Extent2D currentExtent;
+    Extent2D minImageExtent;
+    Extent2D maxImageExtent;
+    uint32_t maxImageArrayLayers;
+    SurfaceTransformFlagsKHR supportedTransforms;
+    SurfaceTransformFlagBitsKHR currentTransform;
+    CompositeAlphaFlagsKHR supportedCompositeAlpha;
+    ImageUsageFlags supportedUsageFlags;
+  };
+  static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
+
+  struct SurfaceCapabilities2KHR
+  {
+    operator VkSurfaceCapabilities2KHR const&() const
+    {
+      return *reinterpret_cast<const VkSurfaceCapabilities2KHR*>( this );
+    }
+
+    operator VkSurfaceCapabilities2KHR &()
+    {
+      return *reinterpret_cast<VkSurfaceCapabilities2KHR*>( this );
+    }
+
+    bool operator==( SurfaceCapabilities2KHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( surfaceCapabilities == rhs.surfaceCapabilities );
+    }
+
+    bool operator!=( SurfaceCapabilities2KHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eSurfaceCapabilities2KHR;
+
+  public:
+    void* pNext = nullptr;
+    SurfaceCapabilitiesKHR surfaceCapabilities;
+  };
+  static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" );
+
+  struct SurfaceFormatKHR
+  {
+    operator VkSurfaceFormatKHR const&() const
+    {
+      return *reinterpret_cast<const VkSurfaceFormatKHR*>( this );
+    }
+
+    operator VkSurfaceFormatKHR &()
+    {
+      return *reinterpret_cast<VkSurfaceFormatKHR*>( this );
+    }
+
+    bool operator==( SurfaceFormatKHR const& rhs ) const
+    {
+      return ( format == rhs.format )
+          && ( colorSpace == rhs.colorSpace );
+    }
+
+    bool operator!=( SurfaceFormatKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
     Format format;
-    uint64_t externalFormat;
-    FormatFeatureFlags formatFeatures;
-    ComponentMapping samplerYcbcrConversionComponents;
-    SamplerYcbcrModelConversion suggestedYcbcrModel;
-    SamplerYcbcrRange suggestedYcbcrRange;
-    ChromaLocation suggestedXChromaOffset;
-    ChromaLocation suggestedYChromaOffset;
+    ColorSpaceKHR colorSpace;
   };
-  static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+  static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" );
 
-  enum class BlendOverlapEXT
+  struct SurfaceFormat2KHR
   {
-    eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
-    eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT,
-    eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT
-  };
-
-  struct PipelineColorBlendAdvancedStateCreateInfoEXT
-  {
-    PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0,
-                                                  Bool32 dstPremultiplied_ = 0,
-                                                  BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated )
-      : srcPremultiplied( srcPremultiplied_ )
-      , dstPremultiplied( dstPremultiplied_ )
-      , blendOverlap( blendOverlap_ )
+    operator VkSurfaceFormat2KHR const&() const
     {
+      return *reinterpret_cast<const VkSurfaceFormat2KHR*>( this );
     }
 
-    PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
+    operator VkSurfaceFormat2KHR &()
     {
-      memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) );
+      return *reinterpret_cast<VkSurfaceFormat2KHR*>( this );
     }
 
-    PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) );
-      return *this;
-    }
-    PipelineColorBlendAdvancedStateCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineColorBlendAdvancedStateCreateInfoEXT& setSrcPremultiplied( Bool32 srcPremultiplied_ )
-    {
-      srcPremultiplied = srcPremultiplied_;
-      return *this;
-    }
-
-    PipelineColorBlendAdvancedStateCreateInfoEXT& setDstPremultiplied( Bool32 dstPremultiplied_ )
-    {
-      dstPremultiplied = dstPremultiplied_;
-      return *this;
-    }
-
-    PipelineColorBlendAdvancedStateCreateInfoEXT& setBlendOverlap( BlendOverlapEXT blendOverlap_ )
-    {
-      blendOverlap = blendOverlap_;
-      return *this;
-    }
-
-    operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this);
-    }
-
-    operator VkPipelineColorBlendAdvancedStateCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this);
-    }
-
-    bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const
+    bool operator==( SurfaceFormat2KHR const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( srcPremultiplied == rhs.srcPremultiplied )
-          && ( dstPremultiplied == rhs.dstPremultiplied )
-          && ( blendOverlap == rhs.blendOverlap );
+          && ( surfaceFormat == rhs.surfaceFormat );
     }
 
-    bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const
+    bool operator!=( SurfaceFormat2KHR const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 srcPremultiplied;
-    Bool32 dstPremultiplied;
-    BlendOverlapEXT blendOverlap;
-  };
-  static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class CoverageModulationModeNV
-  {
-    eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV,
-    eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV,
-    eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV,
-    eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV
-  };
-
-  struct PipelineCoverageModulationStateCreateInfoNV
-  {
-    PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(),
-                                                 CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone,
-                                                 Bool32 coverageModulationTableEnable_ = 0,
-                                                 uint32_t coverageModulationTableCount_ = 0,
-                                                 const float* pCoverageModulationTable_ = nullptr )
-      : flags( flags_ )
-      , coverageModulationMode( coverageModulationMode_ )
-      , coverageModulationTableEnable( coverageModulationTableEnable_ )
-      , coverageModulationTableCount( coverageModulationTableCount_ )
-      , pCoverageModulationTable( pCoverageModulationTable_ )
-    {
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
-      return *this;
-    }
-    PipelineCoverageModulationStateCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV& setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ )
-    {
-      coverageModulationMode = coverageModulationMode_;
-      return *this;
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ )
-    {
-      coverageModulationTableEnable = coverageModulationTableEnable_;
-      return *this;
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableCount( uint32_t coverageModulationTableCount_ )
-    {
-      coverageModulationTableCount = coverageModulationTableCount_;
-      return *this;
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV& setPCoverageModulationTable( const float* pCoverageModulationTable_ )
-    {
-      pCoverageModulationTable = pCoverageModulationTable_;
-      return *this;
-    }
-
-    operator VkPipelineCoverageModulationStateCreateInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(this);
-    }
-
-    operator VkPipelineCoverageModulationStateCreateInfoNV &()
-    {
-      return *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(this);
-    }
-
-    bool operator==( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( coverageModulationMode == rhs.coverageModulationMode )
-          && ( coverageModulationTableEnable == rhs.coverageModulationTableEnable )
-          && ( coverageModulationTableCount == rhs.coverageModulationTableCount )
-          && ( pCoverageModulationTable == rhs.pCoverageModulationTable );
-    }
-
-    bool operator!=( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCoverageModulationStateCreateFlagsNV flags;
-    CoverageModulationModeNV coverageModulationMode;
-    Bool32 coverageModulationTableEnable;
-    uint32_t coverageModulationTableCount;
-    const float* pCoverageModulationTable;
-  };
-  static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" );
-
-  enum class ValidationCacheHeaderVersionEXT
-  {
-    eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT
-  };
-
-  enum class ShaderInfoTypeAMD
-  {
-    eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
-    eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD,
-    eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD
-  };
-
-  enum class QueueGlobalPriorityEXT
-  {
-    eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT,
-    eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT,
-    eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT,
-    eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT
-  };
-
-  struct DeviceQueueGlobalPriorityCreateInfoEXT
-  {
-    DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow )
-      : globalPriority( globalPriority_ )
-    {
-    }
-
-    DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
-    }
-
-    DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
-      return *this;
-    }
-    DeviceQueueGlobalPriorityCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceQueueGlobalPriorityCreateInfoEXT& setGlobalPriority( QueueGlobalPriorityEXT globalPriority_ )
-    {
-      globalPriority = globalPriority_;
-      return *this;
-    }
-
-    operator VkDeviceQueueGlobalPriorityCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this);
-    }
-
-    operator VkDeviceQueueGlobalPriorityCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this);
-    }
-
-    bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( globalPriority == rhs.globalPriority );
-    }
-
-    bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    QueueGlobalPriorityEXT globalPriority;
-  };
-  static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class DebugUtilsMessageSeverityFlagBitsEXT
-  {
-    eVerbose = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT,
-    eInfo = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT,
-    eWarning = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT,
-    eError = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT
-  };
-
-  using DebugUtilsMessageSeverityFlagsEXT = Flags<DebugUtilsMessageSeverityFlagBitsEXT, VkDebugUtilsMessageSeverityFlagsEXT>;
-
-  VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator|( DebugUtilsMessageSeverityFlagBitsEXT bit0, DebugUtilsMessageSeverityFlagBitsEXT bit1 )
-  {
-    return DebugUtilsMessageSeverityFlagsEXT( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator~( DebugUtilsMessageSeverityFlagBitsEXT bits )
-  {
-    return ~( DebugUtilsMessageSeverityFlagsEXT( bits ) );
-  }
-
-  template <> struct FlagTraits<DebugUtilsMessageSeverityFlagBitsEXT>
-  {
-    enum
-    {
-      allFlags = VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eVerbose) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eInfo) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eWarning) | VkFlags(DebugUtilsMessageSeverityFlagBitsEXT::eError)
-    };
-  };
-
-  enum class DebugUtilsMessageTypeFlagBitsEXT
-  {
-    eGeneral = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT,
-    eValidation = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
-    ePerformance = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
-  };
-
-  using DebugUtilsMessageTypeFlagsEXT = Flags<DebugUtilsMessageTypeFlagBitsEXT, VkDebugUtilsMessageTypeFlagsEXT>;
-
-  VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator|( DebugUtilsMessageTypeFlagBitsEXT bit0, DebugUtilsMessageTypeFlagBitsEXT bit1 )
-  {
-    return DebugUtilsMessageTypeFlagsEXT( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator~( DebugUtilsMessageTypeFlagBitsEXT bits )
-  {
-    return ~( DebugUtilsMessageTypeFlagsEXT( bits ) );
-  }
-
-  template <> struct FlagTraits<DebugUtilsMessageTypeFlagBitsEXT>
-  {
-    enum
-    {
-      allFlags = VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eGeneral) | VkFlags(DebugUtilsMessageTypeFlagBitsEXT::eValidation) | VkFlags(DebugUtilsMessageTypeFlagBitsEXT::ePerformance)
-    };
-  };
-
-  struct DebugUtilsMessengerCreateInfoEXT
-  {
-    DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT flags_ = DebugUtilsMessengerCreateFlagsEXT(),
-                                      DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = DebugUtilsMessageSeverityFlagsEXT(),
-                                      DebugUtilsMessageTypeFlagsEXT messageType_ = DebugUtilsMessageTypeFlagsEXT(),
-                                      PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr,
-                                      void* pUserData_ = nullptr )
-      : flags( flags_ )
-      , messageSeverity( messageSeverity_ )
-      , messageType( messageType_ )
-      , pfnUserCallback( pfnUserCallback_ )
-      , pUserData( pUserData_ )
-    {
-    }
-
-    DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) );
-    }
-
-    DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) );
-      return *this;
-    }
-    DebugUtilsMessengerCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCreateInfoEXT& setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCreateInfoEXT& setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ )
-    {
-      messageSeverity = messageSeverity_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCreateInfoEXT& setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ )
-    {
-      messageType = messageType_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCreateInfoEXT& setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ )
-    {
-      pfnUserCallback = pfnUserCallback_;
-      return *this;
-    }
-
-    DebugUtilsMessengerCreateInfoEXT& setPUserData( void* pUserData_ )
-    {
-      pUserData = pUserData_;
-      return *this;
-    }
-
-    operator VkDebugUtilsMessengerCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(this);
-    }
-
-    operator VkDebugUtilsMessengerCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(this);
-    }
-
-    bool operator==( DebugUtilsMessengerCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( messageSeverity == rhs.messageSeverity )
-          && ( messageType == rhs.messageType )
-          && ( pfnUserCallback == rhs.pfnUserCallback )
-          && ( pUserData == rhs.pUserData );
-    }
-
-    bool operator!=( DebugUtilsMessengerCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DebugUtilsMessengerCreateFlagsEXT flags;
-    DebugUtilsMessageSeverityFlagsEXT messageSeverity;
-    DebugUtilsMessageTypeFlagsEXT messageType;
-    PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
-    void* pUserData;
-  };
-  static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class ConservativeRasterizationModeEXT
-  {
-    eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT,
-    eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT,
-    eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT
-  };
-
-  struct PipelineRasterizationConservativeStateCreateInfoEXT
-  {
-    PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = PipelineRasterizationConservativeStateCreateFlagsEXT(),
-                                                         ConservativeRasterizationModeEXT conservativeRasterizationMode_ = ConservativeRasterizationModeEXT::eDisabled,
-                                                         float extraPrimitiveOverestimationSize_ = 0 )
-      : flags( flags_ )
-      , conservativeRasterizationMode( conservativeRasterizationMode_ )
-      , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
-    {
-    }
-
-    PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
-    }
-
-    PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
-      return *this;
-    }
-    PipelineRasterizationConservativeStateCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineRasterizationConservativeStateCreateInfoEXT& setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineRasterizationConservativeStateCreateInfoEXT& setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ )
-    {
-      conservativeRasterizationMode = conservativeRasterizationMode_;
-      return *this;
-    }
-
-    PipelineRasterizationConservativeStateCreateInfoEXT& setExtraPrimitiveOverestimationSize( float extraPrimitiveOverestimationSize_ )
-    {
-      extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_;
-      return *this;
-    }
-
-    operator VkPipelineRasterizationConservativeStateCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this);
-    }
-
-    operator VkPipelineRasterizationConservativeStateCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this);
-    }
-
-    bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( conservativeRasterizationMode == rhs.conservativeRasterizationMode )
-          && ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize );
-    }
-
-    bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineRasterizationConservativeStateCreateFlagsEXT flags;
-    ConservativeRasterizationModeEXT conservativeRasterizationMode;
-    float extraPrimitiveOverestimationSize;
-  };
-  static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class DescriptorBindingFlagBitsEXT
-  {
-    eUpdateAfterBind = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT,
-    eUpdateUnusedWhilePending = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT,
-    ePartiallyBound = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT,
-    eVariableDescriptorCount = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT
-  };
-
-  using DescriptorBindingFlagsEXT = Flags<DescriptorBindingFlagBitsEXT, VkDescriptorBindingFlagsEXT>;
-
-  VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator|( DescriptorBindingFlagBitsEXT bit0, DescriptorBindingFlagBitsEXT bit1 )
-  {
-    return DescriptorBindingFlagsEXT( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator~( DescriptorBindingFlagBitsEXT bits )
-  {
-    return ~( DescriptorBindingFlagsEXT( bits ) );
-  }
-
-  template <> struct FlagTraits<DescriptorBindingFlagBitsEXT>
-  {
-    enum
-    {
-      allFlags = VkFlags(DescriptorBindingFlagBitsEXT::eUpdateAfterBind) | VkFlags(DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending) | VkFlags(DescriptorBindingFlagBitsEXT::ePartiallyBound) | VkFlags(DescriptorBindingFlagBitsEXT::eVariableDescriptorCount)
-    };
-  };
-
-  struct DescriptorSetLayoutBindingFlagsCreateInfoEXT
-  {
-    DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0,
-                                                  const DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr )
-      : bindingCount( bindingCount_ )
-      , pBindingFlags( pBindingFlags_ )
-    {
-    }
-
-    DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) );
-    }
-
-    DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) );
-      return *this;
-    }
-    DescriptorSetLayoutBindingFlagsCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DescriptorSetLayoutBindingFlagsCreateInfoEXT& setBindingCount( uint32_t bindingCount_ )
-    {
-      bindingCount = bindingCount_;
-      return *this;
-    }
-
-    DescriptorSetLayoutBindingFlagsCreateInfoEXT& setPBindingFlags( const DescriptorBindingFlagsEXT* pBindingFlags_ )
-    {
-      pBindingFlags = pBindingFlags_;
-      return *this;
-    }
-
-    operator VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this);
-    }
-
-    operator VkDescriptorSetLayoutBindingFlagsCreateInfoEXT &()
-    {
-      return *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this);
-    }
-
-    bool operator==( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( bindingCount == rhs.bindingCount )
-          && ( pBindingFlags == rhs.pBindingFlags );
-    }
-
-    bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t bindingCount;
-    const DescriptorBindingFlagsEXT* pBindingFlags;
-  };
-  static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class VendorId
-  {
-    eViv = VK_VENDOR_ID_VIV,
-    eVsi = VK_VENDOR_ID_VSI,
-    eKazan = VK_VENDOR_ID_KAZAN
-  };
-
-  enum class DriverIdKHR
-  {
-    eAmdProprietary = VK_DRIVER_ID_AMD_PROPRIETARY_KHR,
-    eAmdOpenSource = VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR,
-    eMesaRadv = VK_DRIVER_ID_MESA_RADV_KHR,
-    eNvidiaProprietary = VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR,
-    eIntelProprietaryWindows = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR,
-    eIntelOpenSourceMesa = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR,
-    eImaginationProprietary = VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR,
-    eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR,
-    eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY_KHR,
-    eGooglePastel = VK_DRIVER_ID_GOOGLE_PASTEL_KHR
-  };
-
-  struct PhysicalDeviceDriverPropertiesKHR
-  {
-    operator VkPhysicalDeviceDriverPropertiesKHR const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceDriverPropertiesKHR*>(this);
-    }
-
-    operator VkPhysicalDeviceDriverPropertiesKHR &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceDriverPropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( driverID == rhs.driverID )
-          && ( memcmp( driverName, rhs.driverName, VK_MAX_DRIVER_NAME_SIZE_KHR * sizeof( char ) ) == 0 )
-          && ( memcmp( driverInfo, rhs.driverInfo, VK_MAX_DRIVER_INFO_SIZE_KHR * sizeof( char ) ) == 0 )
-          && ( conformanceVersion == rhs.conformanceVersion );
-    }
-
-    bool operator!=( PhysicalDeviceDriverPropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceDriverPropertiesKHR;
+    StructureType sType = StructureType::eSurfaceFormat2KHR;
 
   public:
     void* pNext = nullptr;
-    DriverIdKHR driverID;
-    char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR];
-    char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR];
-    ConformanceVersionKHR conformanceVersion;
+    SurfaceFormatKHR surfaceFormat;
   };
-  static_assert( sizeof( PhysicalDeviceDriverPropertiesKHR ) == sizeof( VkPhysicalDeviceDriverPropertiesKHR ), "struct and wrapper have different size!" );
+  static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" );
 
-  enum class ConditionalRenderingFlagBitsEXT
+  struct SwapchainCounterCreateInfoEXT
   {
-    eInverted = VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT
-  };
+    SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() )
+      : surfaceCounters( surfaceCounters_ )
+    {}
 
-  using ConditionalRenderingFlagsEXT = Flags<ConditionalRenderingFlagBitsEXT, VkConditionalRenderingFlagsEXT>;
-
-  VULKAN_HPP_INLINE ConditionalRenderingFlagsEXT operator|( ConditionalRenderingFlagBitsEXT bit0, ConditionalRenderingFlagBitsEXT bit1 )
-  {
-    return ConditionalRenderingFlagsEXT( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ConditionalRenderingFlagsEXT operator~( ConditionalRenderingFlagBitsEXT bits )
-  {
-    return ~( ConditionalRenderingFlagsEXT( bits ) );
-  }
-
-  template <> struct FlagTraits<ConditionalRenderingFlagBitsEXT>
-  {
-    enum
-    {
-      allFlags = VkFlags(ConditionalRenderingFlagBitsEXT::eInverted)
-    };
-  };
-
-  struct ConditionalRenderingBeginInfoEXT
-  {
-    ConditionalRenderingBeginInfoEXT( Buffer buffer_ = Buffer(),
-                                      DeviceSize offset_ = 0,
-                                      ConditionalRenderingFlagsEXT flags_ = ConditionalRenderingFlagsEXT() )
-      : buffer( buffer_ )
-      , offset( offset_ )
-      , flags( flags_ )
+    SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs )
     {
+      memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
     }
 
-    ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs )
+    SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs )
     {
-      memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) );
-    }
-
-    ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) );
+      memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
       return *this;
     }
-    ConditionalRenderingBeginInfoEXT& setPNext( const void* pNext_ )
+
+    SwapchainCounterCreateInfoEXT & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    ConditionalRenderingBeginInfoEXT& setBuffer( Buffer buffer_ )
+    SwapchainCounterCreateInfoEXT & setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ )
     {
-      buffer = buffer_;
+      surfaceCounters = surfaceCounters_;
       return *this;
     }
 
-    ConditionalRenderingBeginInfoEXT& setOffset( DeviceSize offset_ )
+    operator VkSwapchainCounterCreateInfoEXT const&() const
     {
-      offset = offset_;
-      return *this;
+      return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>( this );
     }
 
-    ConditionalRenderingBeginInfoEXT& setFlags( ConditionalRenderingFlagsEXT flags_ )
+    operator VkSwapchainCounterCreateInfoEXT &()
     {
-      flags = flags_;
-      return *this;
+      return *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>( this );
     }
 
-    operator VkConditionalRenderingBeginInfoEXT const&() const
-    {
-      return *reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>(this);
-    }
-
-    operator VkConditionalRenderingBeginInfoEXT &()
-    {
-      return *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>(this);
-    }
-
-    bool operator==( ConditionalRenderingBeginInfoEXT const& rhs ) const
+    bool operator==( SwapchainCounterCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( buffer == rhs.buffer )
-          && ( offset == rhs.offset )
-          && ( flags == rhs.flags );
+          && ( surfaceCounters == rhs.surfaceCounters );
     }
 
-    bool operator!=( ConditionalRenderingBeginInfoEXT const& rhs ) const
+    bool operator!=( SwapchainCounterCreateInfoEXT const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT;
+    StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT;
 
   public:
     const void* pNext = nullptr;
-    Buffer buffer;
-    DeviceSize offset;
-    ConditionalRenderingFlagsEXT flags;
+    SurfaceCounterFlagsEXT surfaceCounters;
   };
-  static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" );
+  static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" );
 
-  enum class ShadingRatePaletteEntryNV
+  struct SwapchainCreateInfoKHR
   {
-    eNoInvocations = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV,
-    e16InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV,
-    e8InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV,
-    e4InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV,
-    e2InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV,
-    e1InvocationPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV,
-    e1InvocationPer2X1Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV,
-    e1InvocationPer1X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV,
-    e1InvocationPer2X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV,
-    e1InvocationPer4X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV,
-    e1InvocationPer2X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV,
-    e1InvocationPer4X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV
-  };
-
-  struct ShadingRatePaletteNV
-  {
-    ShadingRatePaletteNV( uint32_t shadingRatePaletteEntryCount_ = 0,
-                          const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ = nullptr )
-      : shadingRatePaletteEntryCount( shadingRatePaletteEntryCount_ )
-      , pShadingRatePaletteEntries( pShadingRatePaletteEntries_ )
-    {
-    }
-
-    ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) );
-    }
-
-    ShadingRatePaletteNV& operator=( VkShadingRatePaletteNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) );
-      return *this;
-    }
-    ShadingRatePaletteNV& setShadingRatePaletteEntryCount( uint32_t shadingRatePaletteEntryCount_ )
-    {
-      shadingRatePaletteEntryCount = shadingRatePaletteEntryCount_;
-      return *this;
-    }
-
-    ShadingRatePaletteNV& setPShadingRatePaletteEntries( const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ )
-    {
-      pShadingRatePaletteEntries = pShadingRatePaletteEntries_;
-      return *this;
-    }
-
-    operator VkShadingRatePaletteNV const&() const
-    {
-      return *reinterpret_cast<const VkShadingRatePaletteNV*>(this);
-    }
-
-    operator VkShadingRatePaletteNV &()
-    {
-      return *reinterpret_cast<VkShadingRatePaletteNV*>(this);
-    }
-
-    bool operator==( ShadingRatePaletteNV const& rhs ) const
-    {
-      return ( shadingRatePaletteEntryCount == rhs.shadingRatePaletteEntryCount )
-          && ( pShadingRatePaletteEntries == rhs.pShadingRatePaletteEntries );
-    }
-
-    bool operator!=( ShadingRatePaletteNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t shadingRatePaletteEntryCount;
-    const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries;
-  };
-  static_assert( sizeof( ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" );
-
-  struct PipelineViewportShadingRateImageStateCreateInfoNV
-  {
-    PipelineViewportShadingRateImageStateCreateInfoNV( Bool32 shadingRateImageEnable_ = 0,
-                                                       uint32_t viewportCount_ = 0,
-                                                       const ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr )
-      : shadingRateImageEnable( shadingRateImageEnable_ )
-      , viewportCount( viewportCount_ )
-      , pShadingRatePalettes( pShadingRatePalettes_ )
-    {
-    }
-
-    PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) );
-    }
-
-    PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) );
-      return *this;
-    }
-    PipelineViewportShadingRateImageStateCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineViewportShadingRateImageStateCreateInfoNV& setShadingRateImageEnable( Bool32 shadingRateImageEnable_ )
-    {
-      shadingRateImageEnable = shadingRateImageEnable_;
-      return *this;
-    }
-
-    PipelineViewportShadingRateImageStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ )
-    {
-      viewportCount = viewportCount_;
-      return *this;
-    }
-
-    PipelineViewportShadingRateImageStateCreateInfoNV& setPShadingRatePalettes( const ShadingRatePaletteNV* pShadingRatePalettes_ )
-    {
-      pShadingRatePalettes = pShadingRatePalettes_;
-      return *this;
-    }
-
-    operator VkPipelineViewportShadingRateImageStateCreateInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this);
-    }
-
-    operator VkPipelineViewportShadingRateImageStateCreateInfoNV &()
-    {
-      return *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this);
-    }
-
-    bool operator==( PipelineViewportShadingRateImageStateCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( shadingRateImageEnable == rhs.shadingRateImageEnable )
-          && ( viewportCount == rhs.viewportCount )
-          && ( pShadingRatePalettes == rhs.pShadingRatePalettes );
-    }
-
-    bool operator!=( PipelineViewportShadingRateImageStateCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 shadingRateImageEnable;
-    uint32_t viewportCount;
-    const ShadingRatePaletteNV* pShadingRatePalettes;
-  };
-  static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "struct and wrapper have different size!" );
-
-  struct CoarseSampleOrderCustomNV
-  {
-    CoarseSampleOrderCustomNV( ShadingRatePaletteEntryNV shadingRate_ = ShadingRatePaletteEntryNV::eNoInvocations,
-                               uint32_t sampleCount_ = 0,
-                               uint32_t sampleLocationCount_ = 0,
-                               const CoarseSampleLocationNV* pSampleLocations_ = nullptr )
-      : shadingRate( shadingRate_ )
-      , sampleCount( sampleCount_ )
-      , sampleLocationCount( sampleLocationCount_ )
-      , pSampleLocations( pSampleLocations_ )
-    {
-    }
-
-    CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) );
-    }
-
-    CoarseSampleOrderCustomNV& operator=( VkCoarseSampleOrderCustomNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) );
-      return *this;
-    }
-    CoarseSampleOrderCustomNV& setShadingRate( ShadingRatePaletteEntryNV shadingRate_ )
-    {
-      shadingRate = shadingRate_;
-      return *this;
-    }
-
-    CoarseSampleOrderCustomNV& setSampleCount( uint32_t sampleCount_ )
-    {
-      sampleCount = sampleCount_;
-      return *this;
-    }
-
-    CoarseSampleOrderCustomNV& setSampleLocationCount( uint32_t sampleLocationCount_ )
-    {
-      sampleLocationCount = sampleLocationCount_;
-      return *this;
-    }
-
-    CoarseSampleOrderCustomNV& setPSampleLocations( const CoarseSampleLocationNV* pSampleLocations_ )
-    {
-      pSampleLocations = pSampleLocations_;
-      return *this;
-    }
-
-    operator VkCoarseSampleOrderCustomNV const&() const
-    {
-      return *reinterpret_cast<const VkCoarseSampleOrderCustomNV*>(this);
-    }
-
-    operator VkCoarseSampleOrderCustomNV &()
-    {
-      return *reinterpret_cast<VkCoarseSampleOrderCustomNV*>(this);
-    }
-
-    bool operator==( CoarseSampleOrderCustomNV const& rhs ) const
-    {
-      return ( shadingRate == rhs.shadingRate )
-          && ( sampleCount == rhs.sampleCount )
-          && ( sampleLocationCount == rhs.sampleLocationCount )
-          && ( pSampleLocations == rhs.pSampleLocations );
-    }
-
-    bool operator!=( CoarseSampleOrderCustomNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ShadingRatePaletteEntryNV shadingRate;
-    uint32_t sampleCount;
-    uint32_t sampleLocationCount;
-    const CoarseSampleLocationNV* pSampleLocations;
-  };
-  static_assert( sizeof( CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), "struct and wrapper have different size!" );
-
-  enum class CoarseSampleOrderTypeNV
-  {
-    eDefault = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV,
-    eCustom = VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV,
-    ePixelMajor = VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV,
-    eSampleMajor = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV
-  };
-
-  struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
-  {
-    PipelineViewportCoarseSampleOrderStateCreateInfoNV( CoarseSampleOrderTypeNV sampleOrderType_ = CoarseSampleOrderTypeNV::eDefault,
-                                                        uint32_t customSampleOrderCount_ = 0,
-                                                        const CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr )
-      : sampleOrderType( sampleOrderType_ )
-      , customSampleOrderCount( customSampleOrderCount_ )
-      , pCustomSampleOrders( pCustomSampleOrders_ )
-    {
-    }
-
-    PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) );
-    }
-
-    PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) );
-      return *this;
-    }
-    PipelineViewportCoarseSampleOrderStateCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineViewportCoarseSampleOrderStateCreateInfoNV& setSampleOrderType( CoarseSampleOrderTypeNV sampleOrderType_ )
-    {
-      sampleOrderType = sampleOrderType_;
-      return *this;
-    }
-
-    PipelineViewportCoarseSampleOrderStateCreateInfoNV& setCustomSampleOrderCount( uint32_t customSampleOrderCount_ )
-    {
-      customSampleOrderCount = customSampleOrderCount_;
-      return *this;
-    }
-
-    PipelineViewportCoarseSampleOrderStateCreateInfoNV& setPCustomSampleOrders( const CoarseSampleOrderCustomNV* pCustomSampleOrders_ )
-    {
-      pCustomSampleOrders = pCustomSampleOrders_;
-      return *this;
-    }
-
-    operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this);
-    }
-
-    operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV &()
-    {
-      return *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this);
-    }
-
-    bool operator==( PipelineViewportCoarseSampleOrderStateCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( sampleOrderType == rhs.sampleOrderType )
-          && ( customSampleOrderCount == rhs.customSampleOrderCount )
-          && ( pCustomSampleOrders == rhs.pCustomSampleOrders );
-    }
-
-    bool operator!=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    CoarseSampleOrderTypeNV sampleOrderType;
-    uint32_t customSampleOrderCount;
-    const CoarseSampleOrderCustomNV* pCustomSampleOrders;
-  };
-  static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "struct and wrapper have different size!" );
-
-  enum class GeometryInstanceFlagBitsNV
-  {
-    eTriangleCullDisable = VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV,
-    eTriangleFrontCounterclockwise = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV,
-    eForceOpaque = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV,
-    eForceNoOpaque = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV
-  };
-
-  using GeometryInstanceFlagsNV = Flags<GeometryInstanceFlagBitsNV, VkGeometryInstanceFlagsNV>;
-
-  VULKAN_HPP_INLINE GeometryInstanceFlagsNV operator|( GeometryInstanceFlagBitsNV bit0, GeometryInstanceFlagBitsNV bit1 )
-  {
-    return GeometryInstanceFlagsNV( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE GeometryInstanceFlagsNV operator~( GeometryInstanceFlagBitsNV bits )
-  {
-    return ~( GeometryInstanceFlagsNV( bits ) );
-  }
-
-  template <> struct FlagTraits<GeometryInstanceFlagBitsNV>
-  {
-    enum
-    {
-      allFlags = VkFlags(GeometryInstanceFlagBitsNV::eTriangleCullDisable) | VkFlags(GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise) | VkFlags(GeometryInstanceFlagBitsNV::eForceOpaque) | VkFlags(GeometryInstanceFlagBitsNV::eForceNoOpaque)
-    };
-  };
-
-  enum class GeometryFlagBitsNV
-  {
-    eOpaque = VK_GEOMETRY_OPAQUE_BIT_NV,
-    eNoDuplicateAnyHitInvocation = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV
-  };
-
-  using GeometryFlagsNV = Flags<GeometryFlagBitsNV, VkGeometryFlagsNV>;
-
-  VULKAN_HPP_INLINE GeometryFlagsNV operator|( GeometryFlagBitsNV bit0, GeometryFlagBitsNV bit1 )
-  {
-    return GeometryFlagsNV( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE GeometryFlagsNV operator~( GeometryFlagBitsNV bits )
-  {
-    return ~( GeometryFlagsNV( bits ) );
-  }
-
-  template <> struct FlagTraits<GeometryFlagBitsNV>
-  {
-    enum
-    {
-      allFlags = VkFlags(GeometryFlagBitsNV::eOpaque) | VkFlags(GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation)
-    };
-  };
-
-  enum class BuildAccelerationStructureFlagBitsNV
-  {
-    eAllowUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV,
-    eAllowCompaction = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV,
-    ePreferFastTrace = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV,
-    ePreferFastBuild = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV,
-    eLowMemory = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV
-  };
-
-  using BuildAccelerationStructureFlagsNV = Flags<BuildAccelerationStructureFlagBitsNV, VkBuildAccelerationStructureFlagsNV>;
-
-  VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator|( BuildAccelerationStructureFlagBitsNV bit0, BuildAccelerationStructureFlagBitsNV bit1 )
-  {
-    return BuildAccelerationStructureFlagsNV( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator~( BuildAccelerationStructureFlagBitsNV bits )
-  {
-    return ~( BuildAccelerationStructureFlagsNV( bits ) );
-  }
-
-  template <> struct FlagTraits<BuildAccelerationStructureFlagBitsNV>
-  {
-    enum
-    {
-      allFlags = VkFlags(BuildAccelerationStructureFlagBitsNV::eAllowUpdate) | VkFlags(BuildAccelerationStructureFlagBitsNV::eAllowCompaction) | VkFlags(BuildAccelerationStructureFlagBitsNV::ePreferFastTrace) | VkFlags(BuildAccelerationStructureFlagBitsNV::ePreferFastBuild) | VkFlags(BuildAccelerationStructureFlagBitsNV::eLowMemory)
-    };
-  };
-
-  enum class CopyAccelerationStructureModeNV
-  {
-    eClone = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV,
-    eCompact = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV
-  };
-
-  enum class AccelerationStructureTypeNV
-  {
-    eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV,
-    eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV
-  };
-
-  enum class GeometryTypeNV
-  {
-    eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_NV,
-    eAabbs = VK_GEOMETRY_TYPE_AABBS_NV
-  };
-
-  struct GeometryNV
-  {
-    GeometryNV( GeometryTypeNV geometryType_ = GeometryTypeNV::eTriangles,
-                GeometryDataNV geometry_ = GeometryDataNV(),
-                GeometryFlagsNV flags_ = GeometryFlagsNV() )
-      : geometryType( geometryType_ )
-      , geometry( geometry_ )
-      , flags( flags_ )
-    {
-    }
-
-    GeometryNV( VkGeometryNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( GeometryNV ) );
-    }
-
-    GeometryNV& operator=( VkGeometryNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( GeometryNV ) );
-      return *this;
-    }
-    GeometryNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    GeometryNV& setGeometryType( GeometryTypeNV geometryType_ )
-    {
-      geometryType = geometryType_;
-      return *this;
-    }
-
-    GeometryNV& setGeometry( GeometryDataNV geometry_ )
-    {
-      geometry = geometry_;
-      return *this;
-    }
-
-    GeometryNV& setFlags( GeometryFlagsNV flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator VkGeometryNV const&() const
-    {
-      return *reinterpret_cast<const VkGeometryNV*>(this);
-    }
-
-    operator VkGeometryNV &()
-    {
-      return *reinterpret_cast<VkGeometryNV*>(this);
-    }
-
-    bool operator==( GeometryNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( geometryType == rhs.geometryType )
-          && ( geometry == rhs.geometry )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( GeometryNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eGeometryNV;
-
-  public:
-    const void* pNext = nullptr;
-    GeometryTypeNV geometryType;
-    GeometryDataNV geometry;
-    GeometryFlagsNV flags;
-  };
-  static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" );
-
-  struct AccelerationStructureInfoNV
-  {
-    AccelerationStructureInfoNV( AccelerationStructureTypeNV type_ = AccelerationStructureTypeNV::eTopLevel,
-                                 BuildAccelerationStructureFlagsNV flags_ = BuildAccelerationStructureFlagsNV(),
-                                 uint32_t instanceCount_ = 0,
-                                 uint32_t geometryCount_ = 0,
-                                 const GeometryNV* pGeometries_ = nullptr )
-      : type( type_ )
-      , flags( flags_ )
-      , instanceCount( instanceCount_ )
-      , geometryCount( geometryCount_ )
-      , pGeometries( pGeometries_ )
-    {
-    }
-
-    AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) );
-    }
-
-    AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) );
-      return *this;
-    }
-    AccelerationStructureInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    AccelerationStructureInfoNV& setType( AccelerationStructureTypeNV type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    AccelerationStructureInfoNV& setFlags( BuildAccelerationStructureFlagsNV flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    AccelerationStructureInfoNV& setInstanceCount( uint32_t instanceCount_ )
-    {
-      instanceCount = instanceCount_;
-      return *this;
-    }
-
-    AccelerationStructureInfoNV& setGeometryCount( uint32_t geometryCount_ )
-    {
-      geometryCount = geometryCount_;
-      return *this;
-    }
-
-    AccelerationStructureInfoNV& setPGeometries( const GeometryNV* pGeometries_ )
-    {
-      pGeometries = pGeometries_;
-      return *this;
-    }
-
-    operator VkAccelerationStructureInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkAccelerationStructureInfoNV*>(this);
-    }
-
-    operator VkAccelerationStructureInfoNV &()
-    {
-      return *reinterpret_cast<VkAccelerationStructureInfoNV*>(this);
-    }
-
-    bool operator==( AccelerationStructureInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( type == rhs.type )
-          && ( flags == rhs.flags )
-          && ( instanceCount == rhs.instanceCount )
-          && ( geometryCount == rhs.geometryCount )
-          && ( pGeometries == rhs.pGeometries );
-    }
-
-    bool operator!=( AccelerationStructureInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eAccelerationStructureInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    AccelerationStructureTypeNV type;
-    BuildAccelerationStructureFlagsNV flags;
-    uint32_t instanceCount;
-    uint32_t geometryCount;
-    const GeometryNV* pGeometries;
-  };
-  static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "struct and wrapper have different size!" );
-
-  struct AccelerationStructureCreateInfoNV
-  {
-    AccelerationStructureCreateInfoNV( DeviceSize compactedSize_ = 0,
-                                       AccelerationStructureInfoNV info_ = AccelerationStructureInfoNV() )
-      : compactedSize( compactedSize_ )
-      , info( info_ )
-    {
-    }
-
-    AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) );
-    }
-
-    AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) );
-      return *this;
-    }
-    AccelerationStructureCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    AccelerationStructureCreateInfoNV& setCompactedSize( DeviceSize compactedSize_ )
-    {
-      compactedSize = compactedSize_;
-      return *this;
-    }
-
-    AccelerationStructureCreateInfoNV& setInfo( AccelerationStructureInfoNV info_ )
-    {
-      info = info_;
-      return *this;
-    }
-
-    operator VkAccelerationStructureCreateInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>(this);
-    }
-
-    operator VkAccelerationStructureCreateInfoNV &()
-    {
-      return *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>(this);
-    }
-
-    bool operator==( AccelerationStructureCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( compactedSize == rhs.compactedSize )
-          && ( info == rhs.info );
-    }
-
-    bool operator!=( AccelerationStructureCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eAccelerationStructureCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceSize compactedSize;
-    AccelerationStructureInfoNV info;
-  };
-  static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "struct and wrapper have different size!" );
-
-  enum class AccelerationStructureMemoryRequirementsTypeNV
-  {
-    eObject = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV,
-    eBuildScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV,
-    eUpdateScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV
-  };
-
-  struct AccelerationStructureMemoryRequirementsInfoNV
-  {
-    AccelerationStructureMemoryRequirementsInfoNV( AccelerationStructureMemoryRequirementsTypeNV type_ = AccelerationStructureMemoryRequirementsTypeNV::eObject,
-                                                   AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV() )
-      : type( type_ )
-      , accelerationStructure( accelerationStructure_ )
-    {
-    }
-
-    AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) );
-    }
-
-    AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) );
-      return *this;
-    }
-    AccelerationStructureMemoryRequirementsInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    AccelerationStructureMemoryRequirementsInfoNV& setType( AccelerationStructureMemoryRequirementsTypeNV type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    AccelerationStructureMemoryRequirementsInfoNV& setAccelerationStructure( AccelerationStructureNV accelerationStructure_ )
-    {
-      accelerationStructure = accelerationStructure_;
-      return *this;
-    }
-
-    operator VkAccelerationStructureMemoryRequirementsInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>(this);
-    }
-
-    operator VkAccelerationStructureMemoryRequirementsInfoNV &()
-    {
-      return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>(this);
-    }
-
-    bool operator==( AccelerationStructureMemoryRequirementsInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( type == rhs.type )
-          && ( accelerationStructure == rhs.accelerationStructure );
-    }
-
-    bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    AccelerationStructureMemoryRequirementsTypeNV type;
-    AccelerationStructureNV accelerationStructure;
-  };
-  static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "struct and wrapper have different size!" );
-
-  enum class RayTracingShaderGroupTypeNV
-  {
-    eGeneral = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV,
-    eTrianglesHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV,
-    eProceduralHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV
-  };
-
-  struct RayTracingShaderGroupCreateInfoNV
-  {
-    RayTracingShaderGroupCreateInfoNV( RayTracingShaderGroupTypeNV type_ = RayTracingShaderGroupTypeNV::eGeneral,
-                                       uint32_t generalShader_ = 0,
-                                       uint32_t closestHitShader_ = 0,
-                                       uint32_t anyHitShader_ = 0,
-                                       uint32_t intersectionShader_ = 0 )
-      : type( type_ )
-      , generalShader( generalShader_ )
-      , closestHitShader( closestHitShader_ )
-      , anyHitShader( anyHitShader_ )
-      , intersectionShader( intersectionShader_ )
-    {
-    }
-
-    RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) );
-    }
-
-    RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) );
-      return *this;
-    }
-    RayTracingShaderGroupCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    RayTracingShaderGroupCreateInfoNV& setType( RayTracingShaderGroupTypeNV type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    RayTracingShaderGroupCreateInfoNV& setGeneralShader( uint32_t generalShader_ )
-    {
-      generalShader = generalShader_;
-      return *this;
-    }
-
-    RayTracingShaderGroupCreateInfoNV& setClosestHitShader( uint32_t closestHitShader_ )
-    {
-      closestHitShader = closestHitShader_;
-      return *this;
-    }
-
-    RayTracingShaderGroupCreateInfoNV& setAnyHitShader( uint32_t anyHitShader_ )
-    {
-      anyHitShader = anyHitShader_;
-      return *this;
-    }
-
-    RayTracingShaderGroupCreateInfoNV& setIntersectionShader( uint32_t intersectionShader_ )
-    {
-      intersectionShader = intersectionShader_;
-      return *this;
-    }
-
-    operator VkRayTracingShaderGroupCreateInfoNV const&() const
-    {
-      return *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoNV*>(this);
-    }
-
-    operator VkRayTracingShaderGroupCreateInfoNV &()
-    {
-      return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>(this);
-    }
-
-    bool operator==( RayTracingShaderGroupCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( type == rhs.type )
-          && ( generalShader == rhs.generalShader )
-          && ( closestHitShader == rhs.closestHitShader )
-          && ( anyHitShader == rhs.anyHitShader )
-          && ( intersectionShader == rhs.intersectionShader );
-    }
-
-    bool operator!=( RayTracingShaderGroupCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    RayTracingShaderGroupTypeNV type;
-    uint32_t generalShader;
-    uint32_t closestHitShader;
-    uint32_t anyHitShader;
-    uint32_t intersectionShader;
-  };
-  static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "struct and wrapper have different size!" );
-
-  struct RayTracingPipelineCreateInfoNV
-  {
-    RayTracingPipelineCreateInfoNV( PipelineCreateFlags flags_ = PipelineCreateFlags(),
-                                    uint32_t stageCount_ = 0,
-                                    const PipelineShaderStageCreateInfo* pStages_ = nullptr,
-                                    uint32_t groupCount_ = 0,
-                                    const RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr,
-                                    uint32_t maxRecursionDepth_ = 0,
-                                    PipelineLayout layout_ = PipelineLayout(),
-                                    Pipeline basePipelineHandle_ = Pipeline(),
-                                    int32_t basePipelineIndex_ = 0 )
+    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() )
       : flags( flags_ )
-      , stageCount( stageCount_ )
-      , pStages( pStages_ )
-      , groupCount( groupCount_ )
-      , pGroups( pGroups_ )
-      , maxRecursionDepth( maxRecursionDepth_ )
-      , layout( layout_ )
-      , basePipelineHandle( basePipelineHandle_ )
-      , basePipelineIndex( basePipelineIndex_ )
+      , surface( surface_ )
+      , minImageCount( minImageCount_ )
+      , imageFormat( imageFormat_ )
+      , imageColorSpace( imageColorSpace_ )
+      , imageExtent( imageExtent_ )
+      , imageArrayLayers( imageArrayLayers_ )
+      , imageUsage( imageUsage_ )
+      , imageSharingMode( imageSharingMode_ )
+      , queueFamilyIndexCount( queueFamilyIndexCount_ )
+      , pQueueFamilyIndices( pQueueFamilyIndices_ )
+      , preTransform( preTransform_ )
+      , compositeAlpha( compositeAlpha_ )
+      , presentMode( presentMode_ )
+      , clipped( clipped_ )
+      , oldSwapchain( oldSwapchain_ )
+    {}
+
+    SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs )
     {
+      memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
     }
 
-    RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs )
+    SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs )
     {
-      memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) );
-    }
-
-    RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) );
+      memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
       return *this;
     }
-    RayTracingPipelineCreateInfoNV& setPNext( const void* pNext_ )
+
+    SwapchainCreateInfoKHR & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV& setFlags( PipelineCreateFlags flags_ )
+    SwapchainCreateInfoKHR & setFlags( SwapchainCreateFlagsKHR flags_ )
     {
       flags = flags_;
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV& setStageCount( uint32_t stageCount_ )
+    SwapchainCreateInfoKHR & setSurface( SurfaceKHR surface_ )
     {
-      stageCount = stageCount_;
+      surface = surface_;
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV& setPStages( const PipelineShaderStageCreateInfo* pStages_ )
+    SwapchainCreateInfoKHR & setMinImageCount( uint32_t minImageCount_ )
     {
-      pStages = pStages_;
+      minImageCount = minImageCount_;
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV& setGroupCount( uint32_t groupCount_ )
+    SwapchainCreateInfoKHR & setImageFormat( Format imageFormat_ )
     {
-      groupCount = groupCount_;
+      imageFormat = imageFormat_;
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV& setPGroups( const RayTracingShaderGroupCreateInfoNV* pGroups_ )
+    SwapchainCreateInfoKHR & setImageColorSpace( ColorSpaceKHR imageColorSpace_ )
     {
-      pGroups = pGroups_;
+      imageColorSpace = imageColorSpace_;
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV& setMaxRecursionDepth( uint32_t maxRecursionDepth_ )
+    SwapchainCreateInfoKHR & setImageExtent( Extent2D imageExtent_ )
     {
-      maxRecursionDepth = maxRecursionDepth_;
+      imageExtent = imageExtent_;
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV& setLayout( PipelineLayout layout_ )
+    SwapchainCreateInfoKHR & setImageArrayLayers( uint32_t imageArrayLayers_ )
     {
-      layout = layout_;
+      imageArrayLayers = imageArrayLayers_;
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV& setBasePipelineHandle( Pipeline basePipelineHandle_ )
+    SwapchainCreateInfoKHR & setImageUsage( ImageUsageFlags imageUsage_ )
     {
-      basePipelineHandle = basePipelineHandle_;
+      imageUsage = imageUsage_;
       return *this;
     }
 
-    RayTracingPipelineCreateInfoNV& setBasePipelineIndex( int32_t basePipelineIndex_ )
+    SwapchainCreateInfoKHR & setImageSharingMode( SharingMode imageSharingMode_ )
     {
-      basePipelineIndex = basePipelineIndex_;
+      imageSharingMode = imageSharingMode_;
       return *this;
     }
 
-    operator VkRayTracingPipelineCreateInfoNV const&() const
+    SwapchainCreateInfoKHR & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
     {
-      return *reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>(this);
+      queueFamilyIndexCount = queueFamilyIndexCount_;
+      return *this;
     }
 
-    operator VkRayTracingPipelineCreateInfoNV &()
+    SwapchainCreateInfoKHR & setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
     {
-      return *reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>(this);
+      pQueueFamilyIndices = pQueueFamilyIndices_;
+      return *this;
     }
 
-    bool operator==( RayTracingPipelineCreateInfoNV const& rhs ) const
+    SwapchainCreateInfoKHR & setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ )
+    {
+      preTransform = preTransform_;
+      return *this;
+    }
+
+    SwapchainCreateInfoKHR & setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ )
+    {
+      compositeAlpha = compositeAlpha_;
+      return *this;
+    }
+
+    SwapchainCreateInfoKHR & setPresentMode( PresentModeKHR presentMode_ )
+    {
+      presentMode = presentMode_;
+      return *this;
+    }
+
+    SwapchainCreateInfoKHR & setClipped( Bool32 clipped_ )
+    {
+      clipped = clipped_;
+      return *this;
+    }
+
+    SwapchainCreateInfoKHR & setOldSwapchain( SwapchainKHR oldSwapchain_ )
+    {
+      oldSwapchain = oldSwapchain_;
+      return *this;
+    }
+
+    operator VkSwapchainCreateInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkSwapchainCreateInfoKHR*>( this );
+    }
+
+    operator VkSwapchainCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkSwapchainCreateInfoKHR*>( this );
+    }
+
+    bool operator==( SwapchainCreateInfoKHR const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
           && ( flags == rhs.flags )
-          && ( stageCount == rhs.stageCount )
-          && ( pStages == rhs.pStages )
-          && ( groupCount == rhs.groupCount )
-          && ( pGroups == rhs.pGroups )
-          && ( maxRecursionDepth == rhs.maxRecursionDepth )
-          && ( layout == rhs.layout )
-          && ( basePipelineHandle == rhs.basePipelineHandle )
-          && ( basePipelineIndex == rhs.basePipelineIndex );
+          && ( surface == rhs.surface )
+          && ( minImageCount == rhs.minImageCount )
+          && ( imageFormat == rhs.imageFormat )
+          && ( imageColorSpace == rhs.imageColorSpace )
+          && ( imageExtent == rhs.imageExtent )
+          && ( imageArrayLayers == rhs.imageArrayLayers )
+          && ( imageUsage == rhs.imageUsage )
+          && ( imageSharingMode == rhs.imageSharingMode )
+          && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
+          && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
+          && ( preTransform == rhs.preTransform )
+          && ( compositeAlpha == rhs.compositeAlpha )
+          && ( presentMode == rhs.presentMode )
+          && ( clipped == rhs.clipped )
+          && ( oldSwapchain == rhs.oldSwapchain );
     }
 
-    bool operator!=( RayTracingPipelineCreateInfoNV const& rhs ) const
+    bool operator!=( SwapchainCreateInfoKHR const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV;
+    StructureType sType = StructureType::eSwapchainCreateInfoKHR;
 
   public:
     const void* pNext = nullptr;
-    PipelineCreateFlags flags;
-    uint32_t stageCount;
-    const PipelineShaderStageCreateInfo* pStages;
-    uint32_t groupCount;
-    const RayTracingShaderGroupCreateInfoNV* pGroups;
-    uint32_t maxRecursionDepth;
-    PipelineLayout layout;
-    Pipeline basePipelineHandle;
-    int32_t basePipelineIndex;
+    SwapchainCreateFlagsKHR flags;
+    SurfaceKHR surface;
+    uint32_t minImageCount;
+    Format imageFormat;
+    ColorSpaceKHR imageColorSpace;
+    Extent2D imageExtent;
+    uint32_t imageArrayLayers;
+    ImageUsageFlags imageUsage;
+    SharingMode imageSharingMode;
+    uint32_t queueFamilyIndexCount;
+    const uint32_t* pQueueFamilyIndices;
+    SurfaceTransformFlagBitsKHR preTransform;
+    CompositeAlphaFlagBitsKHR compositeAlpha;
+    PresentModeKHR presentMode;
+    Bool32 clipped;
+    SwapchainKHR oldSwapchain;
   };
-  static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "struct and wrapper have different size!" );
+  static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
 
-  enum class MemoryOverallocationBehaviorAMD
+  struct TextureLODGatherFormatPropertiesAMD
   {
-    eDefault = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD,
-    eAllowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD,
-    eDisallowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD
-  };
-
-  struct DeviceMemoryOverallocationCreateInfoAMD
-  {
-    DeviceMemoryOverallocationCreateInfoAMD( MemoryOverallocationBehaviorAMD overallocationBehavior_ = MemoryOverallocationBehaviorAMD::eDefault )
-      : overallocationBehavior( overallocationBehavior_ )
+    operator VkTextureLODGatherFormatPropertiesAMD const&() const
     {
+      return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>( this );
     }
 
-    DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
+    operator VkTextureLODGatherFormatPropertiesAMD &()
     {
-      memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) );
+      return *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>( this );
     }
 
-    DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
+    bool operator==( TextureLODGatherFormatPropertiesAMD const& rhs ) const
     {
-      memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) );
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD );
+    }
+
+    bool operator!=( TextureLODGatherFormatPropertiesAMD const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD;
+
+  public:
+    void* pNext = nullptr;
+    Bool32 supportsTextureGatherLODBiasAMD;
+  };
+  static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" );
+
+  struct ValidationCacheCreateInfoEXT
+  {
+    ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_ = ValidationCacheCreateFlagsEXT(),
+                                  size_t initialDataSize_ = 0,
+                                  const void* pInitialData_ = nullptr )
+      : flags( flags_ )
+      , initialDataSize( initialDataSize_ )
+      , pInitialData( pInitialData_ )
+    {}
+
+    ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) );
+    }
+
+    ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) );
       return *this;
     }
-    DeviceMemoryOverallocationCreateInfoAMD& setPNext( const void* pNext_ )
+
+    ValidationCacheCreateInfoEXT & setPNext( const void* pNext_ )
     {
       pNext = pNext_;
       return *this;
     }
 
-    DeviceMemoryOverallocationCreateInfoAMD& setOverallocationBehavior( MemoryOverallocationBehaviorAMD overallocationBehavior_ )
+    ValidationCacheCreateInfoEXT & setFlags( ValidationCacheCreateFlagsEXT flags_ )
     {
-      overallocationBehavior = overallocationBehavior_;
+      flags = flags_;
       return *this;
     }
 
-    operator VkDeviceMemoryOverallocationCreateInfoAMD const&() const
+    ValidationCacheCreateInfoEXT & setInitialDataSize( size_t initialDataSize_ )
     {
-      return *reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(this);
+      initialDataSize = initialDataSize_;
+      return *this;
     }
 
-    operator VkDeviceMemoryOverallocationCreateInfoAMD &()
+    ValidationCacheCreateInfoEXT & setPInitialData( const void* pInitialData_ )
     {
-      return *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(this);
+      pInitialData = pInitialData_;
+      return *this;
     }
 
-    bool operator==( DeviceMemoryOverallocationCreateInfoAMD const& rhs ) const
+    operator VkValidationCacheCreateInfoEXT const&() const
+    {
+      return *reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( this );
+    }
+
+    operator VkValidationCacheCreateInfoEXT &()
+    {
+      return *reinterpret_cast<VkValidationCacheCreateInfoEXT*>( this );
+    }
+
+    bool operator==( ValidationCacheCreateInfoEXT const& rhs ) const
     {
       return ( sType == rhs.sType )
           && ( pNext == rhs.pNext )
-          && ( overallocationBehavior == rhs.overallocationBehavior );
+          && ( flags == rhs.flags )
+          && ( initialDataSize == rhs.initialDataSize )
+          && ( pInitialData == rhs.pInitialData );
     }
 
-    bool operator!=( DeviceMemoryOverallocationCreateInfoAMD const& rhs ) const
+    bool operator!=( ValidationCacheCreateInfoEXT const& rhs ) const
     {
       return !operator==( rhs );
     }
 
   private:
-    StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD;
+    StructureType sType = StructureType::eValidationCacheCreateInfoEXT;
 
   public:
     const void* pNext = nullptr;
-    MemoryOverallocationBehaviorAMD overallocationBehavior;
+    ValidationCacheCreateFlagsEXT flags;
+    size_t initialDataSize;
+    const void* pInitialData;
   };
-  static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "struct and wrapper have different size!" );
+  static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
 
-  template<typename Dispatch = DispatchLoaderStatic>
-  Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d = Dispatch() );
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch = DispatchLoaderStatic>
-  ResultValueType<uint32_t>::type enumerateInstanceVersion(Dispatch const &d = Dispatch() );
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d)
+  struct ValidationFlagsEXT
   {
-    return static_cast<Result>( d.vkEnumerateInstanceVersion( pApiVersion ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<uint32_t>::type enumerateInstanceVersion(Dispatch const &d )
-  {
-    uint32_t apiVersion;
-    Result result = static_cast<Result>( d.vkEnumerateInstanceVersion( &apiVersion ) );
-    return createResultValue( result, apiVersion, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceVersion" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0,
+                        const ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
+      : disabledValidationCheckCount( disabledValidationCheckCount_ )
+      , pDisabledValidationChecks( pDisabledValidationChecks_ )
+    {}
 
-
-  template<typename Dispatch = DispatchLoaderStatic>
-  Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() );
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic> 
-  typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Dispatch const &d = Dispatch() );
-  template <typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic> 
-  typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d );
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d)
-  {
-    return static_cast<Result>( d.vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Dispatch const &d )
-  {
-    std::vector<LayerProperties,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
+    ValidationFlagsEXT( VkValidationFlagsEXT const & rhs )
     {
-      result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
+      memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
     }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceLayerProperties" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d )
-  {
-    std::vector<LayerProperties,Allocator> properties( vectorAllocator );
-    uint32_t propertyCount;
-    Result result;
-    do
+
+    ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs )
     {
-      result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
+      memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
+      return *this;
     }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceLayerProperties" );
+
+    ValidationFlagsEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ValidationFlagsEXT & setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ )
+    {
+      disabledValidationCheckCount = disabledValidationCheckCount_;
+      return *this;
+    }
+
+    ValidationFlagsEXT & setPDisabledValidationChecks( const ValidationCheckEXT* pDisabledValidationChecks_ )
+    {
+      pDisabledValidationChecks = pDisabledValidationChecks_;
+      return *this;
+    }
+
+    operator VkValidationFlagsEXT const&() const
+    {
+      return *reinterpret_cast<const VkValidationFlagsEXT*>( this );
+    }
+
+    operator VkValidationFlagsEXT &()
+    {
+      return *reinterpret_cast<VkValidationFlagsEXT*>( this );
+    }
+
+    bool operator==( ValidationFlagsEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount )
+          && ( pDisabledValidationChecks == rhs.pDisabledValidationChecks );
+    }
+
+    bool operator!=( ValidationFlagsEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eValidationFlagsEXT;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t disabledValidationCheckCount;
+    const ValidationCheckEXT* pDisabledValidationChecks;
+  };
+  static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_VI_NN
+  struct ViSurfaceCreateInfoNN
+  {
+    ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = ViSurfaceCreateFlagsNN(),
+                           void* window_ = nullptr )
+      : flags( flags_ )
+      , window( window_ )
+    {}
+
+    ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) );
+    }
+
+    ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) );
+      return *this;
+    }
+
+    ViSurfaceCreateInfoNN & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    ViSurfaceCreateInfoNN & setFlags( ViSurfaceCreateFlagsNN flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    ViSurfaceCreateInfoNN & setWindow( void* window_ )
+    {
+      window = window_;
+      return *this;
+    }
+
+    operator VkViSurfaceCreateInfoNN const&() const
+    {
+      return *reinterpret_cast<const VkViSurfaceCreateInfoNN*>( this );
+    }
+
+    operator VkViSurfaceCreateInfoNN &()
+    {
+      return *reinterpret_cast<VkViSurfaceCreateInfoNN*>( this );
+    }
+
+    bool operator==( ViSurfaceCreateInfoNN const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( window == rhs.window );
+    }
+
+    bool operator!=( ViSurfaceCreateInfoNN const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eViSurfaceCreateInfoNN;
+
+  public:
+    const void* pNext = nullptr;
+    ViSurfaceCreateFlagsNN flags;
+    void* window;
+  };
+  static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_VI_NN*/
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+  struct WaylandSurfaceCreateInfoKHR
+  {
+    WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = WaylandSurfaceCreateFlagsKHR(),
+                                 struct wl_display* display_ = nullptr,
+                                 struct wl_surface* surface_ = nullptr )
+      : flags( flags_ )
+      , display( display_ )
+      , surface( surface_ )
+    {}
+
+    WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) );
+    }
+
+    WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) );
+      return *this;
+    }
+
+    WaylandSurfaceCreateInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    WaylandSurfaceCreateInfoKHR & setFlags( WaylandSurfaceCreateFlagsKHR flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    WaylandSurfaceCreateInfoKHR & setDisplay( struct wl_display* display_ )
+    {
+      display = display_;
+      return *this;
+    }
+
+    WaylandSurfaceCreateInfoKHR & setSurface( struct wl_surface* surface_ )
+    {
+      surface = surface_;
+      return *this;
+    }
+
+    operator VkWaylandSurfaceCreateInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( this );
+    }
+
+    operator VkWaylandSurfaceCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>( this );
+    }
+
+    bool operator==( WaylandSurfaceCreateInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( display == rhs.display )
+          && ( surface == rhs.surface );
+    }
+
+    bool operator!=( WaylandSurfaceCreateInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    WaylandSurfaceCreateFlagsKHR flags;
+    struct wl_display* display;
+    struct wl_surface* surface;
+  };
+  static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  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 )
+      : acquireCount( acquireCount_ )
+      , pAcquireSyncs( pAcquireSyncs_ )
+      , pAcquireKeys( pAcquireKeys_ )
+      , pAcquireTimeouts( pAcquireTimeouts_ )
+      , releaseCount( releaseCount_ )
+      , pReleaseSyncs( pReleaseSyncs_ )
+      , pReleaseKeys( pReleaseKeys_ )
+    {}
+
+    Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) );
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) );
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoKHR & setAcquireCount( uint32_t acquireCount_ )
+    {
+      acquireCount = acquireCount_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
+    {
+      pAcquireSyncs = pAcquireSyncs_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireKeys( const uint64_t* pAcquireKeys_ )
+    {
+      pAcquireKeys = pAcquireKeys_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireTimeouts( const uint32_t* pAcquireTimeouts_ )
+    {
+      pAcquireTimeouts = pAcquireTimeouts_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoKHR & setReleaseCount( uint32_t releaseCount_ )
+    {
+      releaseCount = releaseCount_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoKHR & setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
+    {
+      pReleaseSyncs = pReleaseSyncs_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoKHR & setPReleaseKeys( const uint64_t* pReleaseKeys_ )
+    {
+      pReleaseKeys = pReleaseKeys_;
+      return *this;
+    }
+
+    operator VkWin32KeyedMutexAcquireReleaseInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>( this );
+    }
+
+    operator VkWin32KeyedMutexAcquireReleaseInfoKHR &()
+    {
+      return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>( this );
+    }
+
+    bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( acquireCount == rhs.acquireCount )
+          && ( pAcquireSyncs == rhs.pAcquireSyncs )
+          && ( pAcquireKeys == rhs.pAcquireKeys )
+          && ( pAcquireTimeouts == rhs.pAcquireTimeouts )
+          && ( releaseCount == rhs.releaseCount )
+          && ( pReleaseSyncs == rhs.pReleaseSyncs )
+          && ( pReleaseKeys == rhs.pReleaseKeys );
+    }
+
+    bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t acquireCount;
+    const DeviceMemory* pAcquireSyncs;
+    const uint64_t* pAcquireKeys;
+    const uint32_t* pAcquireTimeouts;
+    uint32_t releaseCount;
+    const DeviceMemory* pReleaseSyncs;
+    const uint64_t* pReleaseKeys;
+  };
+  static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  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 )
+      : acquireCount( acquireCount_ )
+      , pAcquireSyncs( pAcquireSyncs_ )
+      , pAcquireKeys( pAcquireKeys_ )
+      , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
+      , releaseCount( releaseCount_ )
+      , pReleaseSyncs( pReleaseSyncs_ )
+      , pReleaseKeys( pReleaseKeys_ )
+    {}
+
+    Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) );
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) );
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoNV & setAcquireCount( uint32_t acquireCount_ )
+    {
+      acquireCount = acquireCount_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
+    {
+      pAcquireSyncs = pAcquireSyncs_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireKeys( const uint64_t* pAcquireKeys_ )
+    {
+      pAcquireKeys = pAcquireKeys_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireTimeoutMilliseconds( const uint32_t* pAcquireTimeoutMilliseconds_ )
+    {
+      pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoNV & setReleaseCount( uint32_t releaseCount_ )
+    {
+      releaseCount = releaseCount_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoNV & setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
+    {
+      pReleaseSyncs = pReleaseSyncs_;
+      return *this;
+    }
+
+    Win32KeyedMutexAcquireReleaseInfoNV & setPReleaseKeys( const uint64_t* pReleaseKeys_ )
+    {
+      pReleaseKeys = pReleaseKeys_;
+      return *this;
+    }
+
+    operator VkWin32KeyedMutexAcquireReleaseInfoNV const&() const
+    {
+      return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>( this );
+    }
+
+    operator VkWin32KeyedMutexAcquireReleaseInfoNV &()
+    {
+      return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>( this );
+    }
+
+    bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( acquireCount == rhs.acquireCount )
+          && ( pAcquireSyncs == rhs.pAcquireSyncs )
+          && ( pAcquireKeys == rhs.pAcquireKeys )
+          && ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds )
+          && ( releaseCount == rhs.releaseCount )
+          && ( pReleaseSyncs == rhs.pReleaseSyncs )
+          && ( pReleaseKeys == rhs.pReleaseKeys );
+    }
+
+    bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t acquireCount;
+    const DeviceMemory* pAcquireSyncs;
+    const uint64_t* pAcquireKeys;
+    const uint32_t* pAcquireTimeoutMilliseconds;
+    uint32_t releaseCount;
+    const DeviceMemory* pReleaseSyncs;
+    const uint64_t* pReleaseKeys;
+  };
+  static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  struct Win32SurfaceCreateInfoKHR
+  {
+    Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = Win32SurfaceCreateFlagsKHR(),
+                               HINSTANCE hinstance_ = 0,
+                               HWND hwnd_ = 0 )
+      : flags( flags_ )
+      , hinstance( hinstance_ )
+      , hwnd( hwnd_ )
+    {}
+
+    Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) );
+    }
+
+    Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) );
+      return *this;
+    }
+
+    Win32SurfaceCreateInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    Win32SurfaceCreateInfoKHR & setFlags( Win32SurfaceCreateFlagsKHR flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    Win32SurfaceCreateInfoKHR & setHinstance( HINSTANCE hinstance_ )
+    {
+      hinstance = hinstance_;
+      return *this;
+    }
+
+    Win32SurfaceCreateInfoKHR & setHwnd( HWND hwnd_ )
+    {
+      hwnd = hwnd_;
+      return *this;
+    }
+
+    operator VkWin32SurfaceCreateInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( this );
+    }
+
+    operator VkWin32SurfaceCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>( this );
+    }
+
+    bool operator==( Win32SurfaceCreateInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( hinstance == rhs.hinstance )
+          && ( hwnd == rhs.hwnd );
+    }
+
+    bool operator!=( Win32SurfaceCreateInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    Win32SurfaceCreateFlagsKHR flags;
+    HINSTANCE hinstance;
+    HWND hwnd;
+  };
+  static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  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 )
+      : dstSet( dstSet_ )
+      , dstBinding( dstBinding_ )
+      , dstArrayElement( dstArrayElement_ )
+      , descriptorCount( descriptorCount_ )
+      , descriptorType( descriptorType_ )
+      , pImageInfo( pImageInfo_ )
+      , pBufferInfo( pBufferInfo_ )
+      , pTexelBufferView( pTexelBufferView_ )
+    {}
+
+    WriteDescriptorSet( VkWriteDescriptorSet const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( WriteDescriptorSet ) );
+    }
+
+    WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( WriteDescriptorSet ) );
+      return *this;
+    }
+
+    WriteDescriptorSet & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    WriteDescriptorSet & setDstSet( DescriptorSet dstSet_ )
+    {
+      dstSet = dstSet_;
+      return *this;
+    }
+
+    WriteDescriptorSet & setDstBinding( uint32_t dstBinding_ )
+    {
+      dstBinding = dstBinding_;
+      return *this;
+    }
+
+    WriteDescriptorSet & setDstArrayElement( uint32_t dstArrayElement_ )
+    {
+      dstArrayElement = dstArrayElement_;
+      return *this;
+    }
+
+    WriteDescriptorSet & setDescriptorCount( uint32_t descriptorCount_ )
+    {
+      descriptorCount = descriptorCount_;
+      return *this;
+    }
+
+    WriteDescriptorSet & setDescriptorType( DescriptorType descriptorType_ )
+    {
+      descriptorType = descriptorType_;
+      return *this;
+    }
+
+    WriteDescriptorSet & setPImageInfo( const DescriptorImageInfo* pImageInfo_ )
+    {
+      pImageInfo = pImageInfo_;
+      return *this;
+    }
+
+    WriteDescriptorSet & setPBufferInfo( const DescriptorBufferInfo* pBufferInfo_ )
+    {
+      pBufferInfo = pBufferInfo_;
+      return *this;
+    }
+
+    WriteDescriptorSet & setPTexelBufferView( const BufferView* pTexelBufferView_ )
+    {
+      pTexelBufferView = pTexelBufferView_;
+      return *this;
+    }
+
+    operator VkWriteDescriptorSet const&() const
+    {
+      return *reinterpret_cast<const VkWriteDescriptorSet*>( this );
+    }
+
+    operator VkWriteDescriptorSet &()
+    {
+      return *reinterpret_cast<VkWriteDescriptorSet*>( this );
+    }
+
+    bool operator==( WriteDescriptorSet const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( dstSet == rhs.dstSet )
+          && ( dstBinding == rhs.dstBinding )
+          && ( dstArrayElement == rhs.dstArrayElement )
+          && ( descriptorCount == rhs.descriptorCount )
+          && ( descriptorType == rhs.descriptorType )
+          && ( pImageInfo == rhs.pImageInfo )
+          && ( pBufferInfo == rhs.pBufferInfo )
+          && ( pTexelBufferView == rhs.pTexelBufferView );
+    }
+
+    bool operator!=( WriteDescriptorSet const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eWriteDescriptorSet;
+
+  public:
+    const void* pNext = nullptr;
+    DescriptorSet dstSet;
+    uint32_t dstBinding;
+    uint32_t dstArrayElement;
+    uint32_t descriptorCount;
+    DescriptorType descriptorType;
+    const DescriptorImageInfo* pImageInfo;
+    const DescriptorBufferInfo* pBufferInfo;
+    const BufferView* pTexelBufferView;
+  };
+  static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" );
+
+  struct WriteDescriptorSetAccelerationStructureNV
+  {
+    WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0,
+                                               const AccelerationStructureNV* pAccelerationStructures_ = nullptr )
+      : accelerationStructureCount( accelerationStructureCount_ )
+      , pAccelerationStructures( pAccelerationStructures_ )
+    {}
+
+    WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) );
+    }
+
+    WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) );
+      return *this;
+    }
+
+    WriteDescriptorSetAccelerationStructureNV & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    WriteDescriptorSetAccelerationStructureNV & setAccelerationStructureCount( uint32_t accelerationStructureCount_ )
+    {
+      accelerationStructureCount = accelerationStructureCount_;
+      return *this;
+    }
+
+    WriteDescriptorSetAccelerationStructureNV & setPAccelerationStructures( const AccelerationStructureNV* pAccelerationStructures_ )
+    {
+      pAccelerationStructures = pAccelerationStructures_;
+      return *this;
+    }
+
+    operator VkWriteDescriptorSetAccelerationStructureNV const&() const
+    {
+      return *reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>( this );
+    }
+
+    operator VkWriteDescriptorSetAccelerationStructureNV &()
+    {
+      return *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>( this );
+    }
+
+    bool operator==( WriteDescriptorSetAccelerationStructureNV const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( accelerationStructureCount == rhs.accelerationStructureCount )
+          && ( pAccelerationStructures == rhs.pAccelerationStructures );
+    }
+
+    bool operator!=( WriteDescriptorSetAccelerationStructureNV const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t accelerationStructureCount;
+    const AccelerationStructureNV* pAccelerationStructures;
+  };
+  static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "struct and wrapper have different size!" );
+
+  struct WriteDescriptorSetInlineUniformBlockEXT
+  {
+    WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0,
+                                             const void* pData_ = nullptr )
+      : dataSize( dataSize_ )
+      , pData( pData_ )
+    {}
+
+    WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) );
+    }
+
+    WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) );
+      return *this;
+    }
+
+    WriteDescriptorSetInlineUniformBlockEXT & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    WriteDescriptorSetInlineUniformBlockEXT & setDataSize( uint32_t dataSize_ )
+    {
+      dataSize = dataSize_;
+      return *this;
+    }
+
+    WriteDescriptorSetInlineUniformBlockEXT & setPData( const void* pData_ )
+    {
+      pData = pData_;
+      return *this;
+    }
+
+    operator VkWriteDescriptorSetInlineUniformBlockEXT const&() const
+    {
+      return *reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>( this );
+    }
+
+    operator VkWriteDescriptorSetInlineUniformBlockEXT &()
+    {
+      return *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>( this );
+    }
+
+    bool operator==( WriteDescriptorSetInlineUniformBlockEXT const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( dataSize == rhs.dataSize )
+          && ( pData == rhs.pData );
+    }
+
+    bool operator!=( WriteDescriptorSetInlineUniformBlockEXT const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT;
+
+  public:
+    const void* pNext = nullptr;
+    uint32_t dataSize;
+    const void* pData;
+  };
+  static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "struct and wrapper have different size!" );
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+  struct XcbSurfaceCreateInfoKHR
+  {
+    XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = XcbSurfaceCreateFlagsKHR(),
+                             xcb_connection_t* connection_ = nullptr,
+                             xcb_window_t window_ = 0 )
+      : flags( flags_ )
+      , connection( connection_ )
+      , window( window_ )
+    {}
+
+    XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) );
+    }
+
+    XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) );
+      return *this;
+    }
+
+    XcbSurfaceCreateInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    XcbSurfaceCreateInfoKHR & setFlags( XcbSurfaceCreateFlagsKHR flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    XcbSurfaceCreateInfoKHR & setConnection( xcb_connection_t* connection_ )
+    {
+      connection = connection_;
+      return *this;
+    }
+
+    XcbSurfaceCreateInfoKHR & setWindow( xcb_window_t window_ )
+    {
+      window = window_;
+      return *this;
+    }
+
+    operator VkXcbSurfaceCreateInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( this );
+    }
+
+    operator VkXcbSurfaceCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>( this );
+    }
+
+    bool operator==( XcbSurfaceCreateInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( connection == rhs.connection )
+          && ( window == rhs.window );
+    }
+
+    bool operator!=( XcbSurfaceCreateInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    XcbSurfaceCreateFlagsKHR flags;
+    xcb_connection_t* connection;
+    xcb_window_t window;
+  };
+  static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+  struct XlibSurfaceCreateInfoKHR
+  {
+    XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = XlibSurfaceCreateFlagsKHR(),
+                              Display* dpy_ = nullptr,
+                              Window window_ = 0 )
+      : flags( flags_ )
+      , dpy( dpy_ )
+      , window( window_ )
+    {}
+
+    XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) );
+    }
+
+    XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs )
+    {
+      memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) );
+      return *this;
+    }
+
+    XlibSurfaceCreateInfoKHR & setPNext( const void* pNext_ )
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    XlibSurfaceCreateInfoKHR & setFlags( XlibSurfaceCreateFlagsKHR flags_ )
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    XlibSurfaceCreateInfoKHR & setDpy( Display* dpy_ )
+    {
+      dpy = dpy_;
+      return *this;
+    }
+
+    XlibSurfaceCreateInfoKHR & setWindow( Window window_ )
+    {
+      window = window_;
+      return *this;
+    }
+
+    operator VkXlibSurfaceCreateInfoKHR const&() const
+    {
+      return *reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( this );
+    }
+
+    operator VkXlibSurfaceCreateInfoKHR &()
+    {
+      return *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>( this );
+    }
+
+    bool operator==( XlibSurfaceCreateInfoKHR const& rhs ) const
+    {
+      return ( sType == rhs.sType )
+          && ( pNext == rhs.pNext )
+          && ( flags == rhs.flags )
+          && ( dpy == rhs.dpy )
+          && ( window == rhs.window );
+    }
+
+    bool operator!=( XlibSurfaceCreateInfoKHR const& rhs ) const
+    {
+      return !operator==( rhs );
+    }
+
+  private:
+    StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR;
+
+  public:
+    const void* pNext = nullptr;
+    XlibSurfaceCreateFlagsKHR flags;
+    Display* dpy;
+    Window window;
+  };
+  static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d)
+  {
+    return static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkInstance*>( pInstance ) ) );
   }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-
-  template<typename Dispatch = DispatchLoaderStatic>
-  Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() );
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic> 
-  typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName = nullptr, Dispatch const &d = Dispatch() );
-  template <typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic> 
-  typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d );
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d )
+  {
+    Instance instance;
+    Result result = static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) );
+    return createResultValue( result, instance, VULKAN_HPP_NAMESPACE_STRING"::createInstance" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Instance,Dispatch>>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d )
+  {
+    Instance instance;
+    Result result = static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) );
+
+    ObjectDestroy<NoParent,Dispatch> deleter( allocator, d );
+    return createResultValue<Instance,Dispatch>( result, instance, VULKAN_HPP_NAMESPACE_STRING"::createInstanceUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
@@ -37984,7 +45498,7 @@ public:
     return static_cast<Result>( d.vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
+  template<typename Allocator, typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName, Dispatch const &d )
   {
     std::vector<ExtensionProperties,Allocator> properties;
@@ -38006,7 +45520,7 @@ public:
     }
     return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceExtensionProperties" );
   }
-  template <typename Allocator, typename Dispatch> 
+  template<typename Allocator, typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d )
   {
     std::vector<ExtensionProperties,Allocator> properties( vectorAllocator );
@@ -38030,531 +45544,73 @@ public:
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-
-  // forward declarations
-  struct CmdProcessCommandsInfoNVX;
-
-  class CommandBuffer
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d)
   {
-  public:
-    VULKAN_HPP_CONSTEXPR CommandBuffer()
-      : m_commandBuffer(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t )
-      : m_commandBuffer(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer )
-      : m_commandBuffer( commandBuffer )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    CommandBuffer & operator=(VkCommandBuffer commandBuffer)
+    return static_cast<Result>( d.vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Dispatch const &d )
+  {
+    std::vector<LayerProperties,Allocator> properties;
+    uint32_t propertyCount;
+    Result result;
+    do
     {
-      m_commandBuffer = commandBuffer;
-      return *this; 
-    }
-#endif
-
-    CommandBuffer & operator=( std::nullptr_t )
+      result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
     {
-      m_commandBuffer = VK_NULL_HANDLE;
-      return *this;
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
     }
-
-    bool operator==( CommandBuffer const & rhs ) const
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceLayerProperties" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d )
+  {
+    std::vector<LayerProperties,Allocator> properties( vectorAllocator );
+    uint32_t propertyCount;
+    Result result;
+    do
     {
-      return m_commandBuffer == rhs.m_commandBuffer;
-    }
-
-    bool operator!=(CommandBuffer const & rhs ) const
+      result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
     {
-      return m_commandBuffer != rhs.m_commandBuffer;
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
     }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceLayerProperties" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    bool operator<(CommandBuffer const & rhs ) const
-    {
-      return m_commandBuffer < rhs.m_commandBuffer;
-    }
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result begin( const CommandBufferBeginInfo* pBeginInfo, Dispatch const &d = Dispatch() ) const;
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d)
+  {
+    return static_cast<Result>( d.vkEnumerateInstanceVersion( pApiVersion ) );
+  }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type begin( const CommandBufferBeginInfo & beginInfo, Dispatch const &d = Dispatch() ) const;
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<uint32_t>::type enumerateInstanceVersion(Dispatch const &d )
+  {
+    uint32_t apiVersion;
+    Result result = static_cast<Result>( d.vkEnumerateInstanceVersion( &apiVersion ) );
+    return createResultValue( result, apiVersion, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceVersion" );
+  }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result end(Dispatch const &d = Dispatch() ) const;
-#else
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type end(Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const;
-#else
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setLineWidth( float lineWidth, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setBlendConstants( const float blendConstants[4], Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy<const DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageBlit> regions, Filter filter, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T, typename Dispatch = DispatchLoaderStatic>
-    void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void clearAttachments( ArrayProxy<const ClearAttachment> attachments, ArrayProxy<const ClearRect> rects, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void endConditionalRenderingEXT(Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T, typename Dispatch = DispatchLoaderStatic>
-    void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void nextSubpass( SubpassContents contents, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void endRenderPass(Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void executeCommands( ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void debugMarkerEndEXT(Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setDeviceMask( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginRenderPass2KHR( const RenderPassBeginInfo* pRenderPassBegin, const SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfoKHR & subpassBeginInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void nextSubpass2KHR( const SubpassBeginInfoKHR* pSubpassBeginInfo, const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void nextSubpass2KHR( const SubpassBeginInfoKHR & subpassBeginInfo, const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void endRenderPass2KHR( const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void endRenderPass2KHR( const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, ArrayProxy<const DeviceSize> sizes, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void writeAccelerationStructuresPropertiesNV( ArrayProxy<const AccelerationStructureNV> accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d = Dispatch() ) const;
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const
-    {
-      return m_commandBuffer;
-    }
-
-    explicit operator bool() const
-    {
-      return m_commandBuffer != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_commandBuffer == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkCommandBuffer m_commandBuffer;
-  };
-
-  static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" );
-
   template<typename Dispatch>
   VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo* pBeginInfo, Dispatch const &d) const
   {
@@ -38569,171 +45625,104 @@ public:
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result CommandBuffer::end(Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::end(Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::end" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::reset" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d) const
-  {
-    d.vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d ) const
-  {
-    d.vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d) const
-  {
-    d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport*>( pViewports ) );
+    d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>( pConditionalRenderingBegin ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, Dispatch const &d ) const
   {
-    d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size() , reinterpret_cast<const VkViewport*>( viewports.data() ) );
+    d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>( &conditionalRenderingBegin ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
   {
-    d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D*>( pScissors ) );
+    d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const
   {
-    d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size() , reinterpret_cast<const VkRect2D*>( scissors.data() ) );
+    d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( &labelInfo ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d) const
   {
-    d.vkCmdSetLineWidth( m_commandBuffer, lineWidth );
+    d.vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d ) const
   {
-    d.vkCmdSetLineWidth( m_commandBuffer, lineWidth );
+    d.vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d) const
   {
-    d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
+    d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d ) const
   {
-    d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
+    d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d) const
   {
-    d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants );
+    d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), static_cast<VkSubpassContents>( contents ) );
   }
-#else
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d ) const
   {
-    d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants );
+    d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), static_cast<VkSubpassContents>( contents ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo* pRenderPassBegin, const SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d) const
   {
-    d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds );
+    d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), reinterpret_cast<const VkSubpassBeginInfoKHR*>( pSubpassBeginInfo ) );
   }
-#else
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfoKHR & subpassBeginInfo, Dispatch const &d ) const
   {
-    d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds );
+    d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), reinterpret_cast<const VkSubpassBeginInfoKHR*>( &subpassBeginInfo ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
   {
-    d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
+    d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast<const VkBuffer*>( pCounterBuffers ), reinterpret_cast<const VkDeviceSize*>( pCounterBufferOffsets ) );
   }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d ) const
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
 #else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d ) const
-  {
-    d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d) const
-  {
-    d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d ) const
-  {
-    d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d) const
-  {
-    d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d ) const
-  {
-    d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
+    if ( counterBuffers.size() != counterBufferOffsets.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkCommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
+    }
+#endif  /*VULKAN_HPP_NO_EXCEPTIONS*/
+    d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBuffers.size() , reinterpret_cast<const VkBuffer*>( counterBuffers.data() ), reinterpret_cast<const VkDeviceSize*>( counterBufferOffsets.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -38754,20 +45743,85 @@ public:
   template<typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d) const
   {
-    d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkIndexType>( indexType ) );
+    d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkIndexType>( indexType ) );
   }
 #else
   template<typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d ) const
   {
-    d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkIndexType>( indexType ) );
+    d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkIndexType>( indexType ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d) const
+  {
+    d.vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d ) const
+  {
+    d.vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d) const
+  {
+    d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d ) const
+  {
+    d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d) const
+  {
+    d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), reinterpret_cast<const VkDeviceSize*>( pOffsets ), reinterpret_cast<const VkDeviceSize*>( pSizes ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, ArrayProxy<const DeviceSize> sizes, Dispatch const &d ) const
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
+#else
+    if ( buffers.size() != offsets.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkCommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" );
+    }
+#endif  /*VULKAN_HPP_NO_EXCEPTIONS*/
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( buffers.size() == sizes.size() );
+#else
+    if ( buffers.size() != sizes.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkCommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" );
+    }
+#endif  /*VULKAN_HPP_NO_EXCEPTIONS*/
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( offsets.size() == sizes.size() );
+#else
+    if ( offsets.size() != sizes.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkCommandBuffer::bindTransformFeedbackBuffersEXT: offsets.size() != sizes.size()" );
+    }
+#endif  /*VULKAN_HPP_NO_EXCEPTIONS*/
+    d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast<const VkBuffer*>( buffers.data() ), reinterpret_cast<const VkDeviceSize*>( offsets.data() ), reinterpret_cast<const VkDeviceSize*>( sizes.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, Dispatch const &d) const
   {
-    d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), pOffsets );
+    d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), reinterpret_cast<const VkDeviceSize*>( pOffsets ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
@@ -38778,120 +45832,10 @@ public:
 #else
     if ( buffers.size() != offsets.size() )
     {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkCommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
     }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast<const VkBuffer*>( buffers.data() ), offsets.data() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d) const
-  {
-    d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d ) const
-  {
-    d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d) const
-  {
-    d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d ) const
-  {
-    d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
-  {
-    d.vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
-  {
-    d.vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
-  {
-    d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
-  {
-    d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d) const
-  {
-    d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d ) const
-  {
-    d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d) const
-  {
-    d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d ) const
-  {
-    d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d) const
-  {
-    d.vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferCopy*>( pRegions ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions, Dispatch const &d ) const
-  {
-    d.vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferCopy*>( regions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d) const
-  {
-    d.vkCmdCopyImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageCopy*>( pRegions ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions, Dispatch const &d ) const
-  {
-    d.vkCmdCopyImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageCopy*>( regions.data() ) );
+#endif  /*VULKAN_HPP_NO_EXCEPTIONS*/
+    d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast<const VkBuffer*>( buffers.data() ), reinterpret_cast<const VkDeviceSize*>( offsets.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -38909,55 +45853,28 @@ public:
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d) const
   {
-    d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
+    d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast<const VkAccelerationStructureInfoNV*>( pInfo ), static_cast<VkBuffer>( instanceData ), static_cast<VkDeviceSize>( instanceOffset ), static_cast<VkBool32>( update ), static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkBuffer>( scratch ), static_cast<VkDeviceSize>( scratchOffset ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d ) const
   {
-    d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
+    d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast<const VkAccelerationStructureInfoNV*>( &info ), static_cast<VkBuffer>( instanceData ), static_cast<VkDeviceSize>( instanceOffset ), static_cast<VkBool32>( update ), static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkBuffer>( scratch ), static_cast<VkDeviceSize>( scratchOffset ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d) const
   {
-    d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
+    d.vkCmdClearAttachments( m_commandBuffer, attachmentCount, reinterpret_cast<const VkClearAttachment*>( pAttachments ), rectCount, reinterpret_cast<const VkClearRect*>( pRects ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy<const ClearAttachment> attachments, ArrayProxy<const ClearRect> rects, Dispatch const &d ) const
   {
-    d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d) const
-  {
-    d.vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, dataSize, pData );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d ) const
-  {
-    d.vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, data.size() * sizeof( T ) , reinterpret_cast<const void*>( data.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d) const
-  {
-    d.vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, size, data );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d ) const
-  {
-    d.vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, size, data );
+    d.vkCmdClearAttachments( m_commandBuffer, attachments.size() , reinterpret_cast<const VkClearAttachment*>( attachments.data() ), rects.size() , reinterpret_cast<const VkClearRect*>( rects.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -38987,166 +45904,69 @@ public:
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d) const
   {
-    d.vkCmdClearAttachments( m_commandBuffer, attachmentCount, reinterpret_cast<const VkClearAttachment*>( pAttachments ), rectCount, reinterpret_cast<const VkClearRect*>( pRects ) );
+    d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkCopyAccelerationStructureModeNV>( mode ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d ) const
+  {
+    d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkCopyAccelerationStructureModeNV>( mode ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d) const
+  {
+    d.vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferCopy*>( pRegions ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy<const ClearAttachment> attachments, ArrayProxy<const ClearRect> rects, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions, Dispatch const &d ) const
   {
-    d.vkCmdClearAttachments( m_commandBuffer, attachments.size() , reinterpret_cast<const VkClearAttachment*>( attachments.data() ), rects.size() , reinterpret_cast<const VkClearRect*>( rects.data() ) );
+    d.vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferCopy*>( regions.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const
   {
-    d.vkCmdResolveImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageResolve*>( pRegions ) );
+    d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d ) const
   {
-    d.vkCmdResolveImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageResolve*>( regions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const
-  {
-    d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d ) const
-  {
-    d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const
-  {
-    d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d ) const
-  {
-    d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
+    d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d) const
   {
-    d.vkCmdWaitEvents( m_commandBuffer, eventCount, reinterpret_cast<const VkEvent*>( pEvents ), static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>( pImageMemoryBarriers ) );
+    d.vkCmdCopyImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageCopy*>( pRegions ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions, Dispatch const &d ) const
   {
-    d.vkCmdWaitEvents( m_commandBuffer, events.size() , reinterpret_cast<const VkEvent*>( events.data() ), static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), memoryBarriers.size() , reinterpret_cast<const VkMemoryBarrier*>( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast<const VkBufferMemoryBarrier*>( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast<const VkImageMemoryBarrier*>( imageMemoryBarriers.data() ) );
+    d.vkCmdCopyImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageCopy*>( regions.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const
   {
-    d.vkCmdPipelineBarrier( m_commandBuffer, static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), static_cast<VkDependencyFlags>( dependencyFlags ), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>( pImageMemoryBarriers ) );
+    d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d ) const
   {
-    d.vkCmdPipelineBarrier( m_commandBuffer, static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), static_cast<VkDependencyFlags>( dependencyFlags ), memoryBarriers.size() , reinterpret_cast<const VkMemoryBarrier*>( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast<const VkBufferMemoryBarrier*>( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast<const VkImageMemoryBarrier*>( imageMemoryBarriers.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d) const
-  {
-    d.vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d ) const
-  {
-    d.vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d) const
-  {
-    d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d ) const
-  {
-    d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d) const
-  {
-    d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>( pConditionalRenderingBegin ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, Dispatch const &d ) const
-  {
-    d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>( &conditionalRenderingBegin ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT(Dispatch const &d) const
-  {
-    d.vkCmdEndConditionalRenderingEXT( m_commandBuffer );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT(Dispatch const &d ) const
-  {
-    d.vkCmdEndConditionalRenderingEXT( m_commandBuffer );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const
-  {
-    d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const
-  {
-    d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d) const
-  {
-    d.vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d ) const
-  {
-    d.vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
+    d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -39154,80 +45974,13 @@ public:
   template<typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d) const
   {
-    d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), dstOffset, stride, static_cast<VkQueryResultFlags>( flags ) );
+    d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) );
   }
 #else
   template<typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d ) const
   {
-    d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), dstOffset, stride, static_cast<VkQueryResultFlags>( flags ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d) const
-  {
-    d.vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, size, pValues );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values, Dispatch const &d ) const
-  {
-    d.vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, values.size() * sizeof( T ) , reinterpret_cast<const void*>( values.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d) const
-  {
-    d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), static_cast<VkSubpassContents>( contents ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d ) const
-  {
-    d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), static_cast<VkSubpassContents>( contents ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d) const
-  {
-    d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d ) const
-  {
-    d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass(Dispatch const &d) const
-  {
-    d.vkCmdEndRenderPass( m_commandBuffer );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass(Dispatch const &d ) const
-  {
-    d.vkCmdEndRenderPass( m_commandBuffer );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
-  {
-    d.vkCmdExecuteCommands( m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::executeCommands( ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
-  {
-    d.vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
+    d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -39273,96 +46026,15 @@ public:
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d) const
   {
-    d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
+    d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d ) const
   {
-    d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
-  {
-    d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
-  {
-    d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d) const
-  {
-    d.vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>( pProcessCommandsInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo, Dispatch const &d ) const
-  {
-    d.vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>( &processCommandsInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d) const
-  {
-    d.vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( pReserveSpaceInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo, Dispatch const &d ) const
-  {
-    d.vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( &reserveSpaceInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d) const
-  {
-    d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites, Dispatch const &d ) const
-  {
-    d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const &d) const
-  {
-    d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const &d ) const
-  {
-    d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d) const
-  {
-    d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d ) const
-  {
-    d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask );
+    d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -39396,161 +46068,71 @@ public:
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d) const
   {
-    d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData );
+    d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d ) const
   {
-    d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d) const
-  {
-    d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewportWScalingNV*>( pViewportWScalings ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings, Dispatch const &d ) const
-  {
-    d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportWScalings.size() , reinterpret_cast<const VkViewportWScalingNV*>( viewportWScalings.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d) const
-  {
-    d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangleCount, reinterpret_cast<const VkRect2D*>( pDiscardRectangles ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles, Dispatch const &d ) const
-  {
-    d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangles.size() , reinterpret_cast<const VkRect2D*>( discardRectangles.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d) const
-  {
-    d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT*>( pSampleLocationsInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const &d ) const
-  {
-    d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT*>( &sampleLocationsInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
-  {
-    d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const
-  {
-    d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( &labelInfo ) );
+    d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT(Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d) const
   {
-    d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer );
+    d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT(Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d ) const
   {
-    d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
-  {
-    d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const
-  {
-    d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( &labelInfo ) );
+    d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d) const
   {
-    d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkBuffer>( dstBuffer ), dstOffset, marker );
+    d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d ) const
   {
-    d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkBuffer>( dstBuffer ), dstOffset, marker );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo* pRenderPassBegin, const SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d) const
-  {
-    d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), reinterpret_cast<const VkSubpassBeginInfoKHR*>( pSubpassBeginInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfoKHR & subpassBeginInfo, Dispatch const &d ) const
-  {
-    d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), reinterpret_cast<const VkSubpassBeginInfoKHR*>( &subpassBeginInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfoKHR* pSubpassBeginInfo, const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
-  {
-    d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfoKHR*>( pSubpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfoKHR*>( pSubpassEndInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfoKHR & subpassBeginInfo, const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d ) const
-  {
-    d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfoKHR*>( &subpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfoKHR*>( &subpassEndInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
-  {
-    d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfoKHR*>( pSubpassEndInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d ) const
-  {
-    d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfoKHR*>( &subpassEndInfo ) );
+    d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
   {
-    d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
+    d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
   {
-    d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
+    d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+  {
+    d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+  {
+    d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -39558,134 +46140,27 @@ public:
   template<typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
   {
-    d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
+    d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
 #else
   template<typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
   {
-    d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
+    d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
   {
-    d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker );
+    d.vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
   {
-    d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d) const
-  {
-    d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), pOffsets, pSizes );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, ArrayProxy<const DeviceSize> sizes, Dispatch const &d ) const
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
-#else
-    if ( buffers.size() != offsets.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" );
-    }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( buffers.size() == sizes.size() );
-#else
-    if ( buffers.size() != sizes.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" );
-    }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( offsets.size() == sizes.size() );
-#else
-    if ( offsets.size() != sizes.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: offsets.size() != sizes.size()" );
-    }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast<const VkBuffer*>( buffers.data() ), offsets.data(), sizes.data() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
-  {
-    d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast<const VkBuffer*>( pCounterBuffers ), pCounterBufferOffsets );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d ) const
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
-#else
-    if ( counterBuffers.size() != counterBufferOffsets.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
-    }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBuffers.size() , reinterpret_cast<const VkBuffer*>( counterBuffers.data() ), counterBufferOffsets.data() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
-  {
-    d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast<const VkBuffer*>( pCounterBuffers ), pCounterBufferOffsets );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d ) const
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
-#else
-    if ( counterBuffers.size() != counterBufferOffsets.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
-    }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBuffers.size() , reinterpret_cast<const VkBuffer*>( counterBuffers.data() ), counterBufferOffsets.data() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d) const
-  {
-    d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d ) const
-  {
-    d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d) const
-  {
-    d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d ) const
-  {
-    d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
+    d.vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -39693,66 +46168,69 @@ public:
   template<typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d) const
   {
-    d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast<VkBuffer>( counterBuffer ), counterBufferOffset, counterOffset, vertexStride );
+    d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast<VkBuffer>( counterBuffer ), static_cast<VkDeviceSize>( counterBufferOffset ), counterOffset, vertexStride );
   }
 #else
   template<typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d ) const
   {
-    d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast<VkBuffer>( counterBuffer ), counterBufferOffset, counterOffset, vertexStride );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d) const
-  {
-    d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast<const VkRect2D*>( pExclusiveScissors ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d ) const
-  {
-    d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissors.size() , reinterpret_cast<const VkRect2D*>( exclusiveScissors.data() ) );
+    d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast<VkBuffer>( counterBuffer ), static_cast<VkDeviceSize>( counterBufferOffset ), counterOffset, vertexStride );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
   {
-    d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
+    d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
   {
-    d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
+    d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
   {
-    d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkShadingRatePaletteNV*>( pShadingRatePalettes ) );
+    d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+#else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
   {
-    d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, shadingRatePalettes.size() , reinterpret_cast<const VkShadingRatePaletteNV*>( shadingRatePalettes.data() ) );
+    d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
   {
-    d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrderCount, reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( pCustomSampleOrders ) );
+    d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
   }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+#else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
   {
-    d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrders.size() , reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( customSampleOrders.data() ) );
+    d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
+  {
+    d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
+  {
+    d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -39772,43 +46250,590 @@ public:
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT(Dispatch const &d) const
   {
-    d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
+    d.vkCmdEndConditionalRenderingEXT( m_commandBuffer );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT(Dispatch const &d ) const
   {
-    d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
+    d.vkCmdEndConditionalRenderingEXT( m_commandBuffer );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT(Dispatch const &d) const
   {
-    d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
+    d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT(Dispatch const &d ) const
   {
-    d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
+    d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d) const
   {
-    d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkCopyAccelerationStructureModeNV>( mode ) );
+    d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d ) const
   {
-    d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkCopyAccelerationStructureModeNV>( mode ) );
+    d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d) const
+  {
+    d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d ) const
+  {
+    d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass(Dispatch const &d) const
+  {
+    d.vkCmdEndRenderPass( m_commandBuffer );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass(Dispatch const &d ) const
+  {
+    d.vkCmdEndRenderPass( m_commandBuffer );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
+  {
+    d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfoKHR*>( pSubpassEndInfo ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d ) const
+  {
+    d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfoKHR*>( &subpassEndInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
+  {
+    d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast<const VkBuffer*>( pCounterBuffers ), reinterpret_cast<const VkDeviceSize*>( pCounterBufferOffsets ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d ) const
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
+#else
+    if ( counterBuffers.size() != counterBufferOffsets.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkCommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
+    }
+#endif  /*VULKAN_HPP_NO_EXCEPTIONS*/
+    d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBuffers.size() , reinterpret_cast<const VkBuffer*>( counterBuffers.data() ), reinterpret_cast<const VkDeviceSize*>( counterBufferOffsets.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
+  {
+    d.vkCmdExecuteCommands( m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::executeCommands( ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
+  {
+    d.vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d) const
+  {
+    d.vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( size ), data );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d ) const
+  {
+    d.vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( size ), data );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
+  {
+    d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const
+  {
+    d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( &labelInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d) const
+  {
+    d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d ) const
+  {
+    d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfoKHR* pSubpassBeginInfo, const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
+  {
+    d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfoKHR*>( pSubpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfoKHR*>( pSubpassEndInfo ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfoKHR & subpassBeginInfo, const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d ) const
+  {
+    d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfoKHR*>( &subpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfoKHR*>( &subpassEndInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const
+  {
+    d.vkCmdPipelineBarrier( m_commandBuffer, static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), static_cast<VkDependencyFlags>( dependencyFlags ), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>( pImageMemoryBarriers ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d ) const
+  {
+    d.vkCmdPipelineBarrier( m_commandBuffer, static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), static_cast<VkDependencyFlags>( dependencyFlags ), memoryBarriers.size() , reinterpret_cast<const VkMemoryBarrier*>( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast<const VkBufferMemoryBarrier*>( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast<const VkImageMemoryBarrier*>( imageMemoryBarriers.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d) const
+  {
+    d.vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>( pProcessCommandsInfo ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo, Dispatch const &d ) const
+  {
+    d.vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>( &processCommandsInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d) const
+  {
+    d.vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, size, pValues );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename T, typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values, Dispatch const &d ) const
+  {
+    d.vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, values.size() * sizeof( T ) , reinterpret_cast<const void*>( values.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d) const
+  {
+    d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites, Dispatch const &d ) const
+  {
+    d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d) const
+  {
+    d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d ) const
+  {
+    d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d) const
+  {
+    d.vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( pReserveSpaceInfo ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo, Dispatch const &d ) const
+  {
+    d.vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( &reserveSpaceInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const
+  {
+    d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d ) const
+  {
+    d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const
+  {
+    d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const
+  {
+    d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d) const
+  {
+    d.vkCmdResolveImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageResolve*>( pRegions ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions, Dispatch const &d ) const
+  {
+    d.vkCmdResolveImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageResolve*>( regions.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const &d) const
+  {
+    d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const &d ) const
+  {
+    d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d) const
+  {
+    d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d ) const
+  {
+    d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d) const
+  {
+    d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrderCount, reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( pCustomSampleOrders ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d ) const
+  {
+    d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrders.size() , reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( customSampleOrders.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d) const
+  {
+    d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d ) const
+  {
+    d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d) const
+  {
+    d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d ) const
+  {
+    d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const &d) const
+  {
+    d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const &d ) const
+  {
+    d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d) const
+  {
+    d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d ) const
+  {
+    d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d) const
+  {
+    d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangleCount, reinterpret_cast<const VkRect2D*>( pDiscardRectangles ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles, Dispatch const &d ) const
+  {
+    d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangles.size() , reinterpret_cast<const VkRect2D*>( discardRectangles.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const
+  {
+    d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d ) const
+  {
+    d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d) const
+  {
+    d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast<const VkRect2D*>( pExclusiveScissors ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d ) const
+  {
+    d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissors.size() , reinterpret_cast<const VkRect2D*>( exclusiveScissors.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const &d) const
+  {
+    d.vkCmdSetLineWidth( m_commandBuffer, lineWidth );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const &d ) const
+  {
+    d.vkCmdSetLineWidth( m_commandBuffer, lineWidth );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d) const
+  {
+    d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT*>( pSampleLocationsInfo ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const &d ) const
+  {
+    d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT*>( &sampleLocationsInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d) const
+  {
+    d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D*>( pScissors ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors, Dispatch const &d ) const
+  {
+    d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size() , reinterpret_cast<const VkRect2D*>( scissors.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d) const
+  {
+    d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d ) const
+  {
+    d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d) const
+  {
+    d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d ) const
+  {
+    d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d) const
+  {
+    d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d ) const
+  {
+    d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d) const
+  {
+    d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport*>( pViewports ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports, Dispatch const &d ) const
+  {
+    d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size() , reinterpret_cast<const VkViewport*>( viewports.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d) const
+  {
+    d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkShadingRatePaletteNV*>( pShadingRatePalettes ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d ) const
+  {
+    d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, shadingRatePalettes.size() , reinterpret_cast<const VkShadingRatePaletteNV*>( shadingRatePalettes.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d) const
+  {
+    d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewportWScalingNV*>( pViewportWScalings ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings, Dispatch const &d ) const
+  {
+    d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportWScalings.size() , reinterpret_cast<const VkViewportWScalingNV*>( viewportWScalings.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d) const
+  {
+    d.vkCmdTraceRaysNV( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), static_cast<VkDeviceSize>( raygenShaderBindingOffset ), static_cast<VkBuffer>( missShaderBindingTableBuffer ), static_cast<VkDeviceSize>( missShaderBindingOffset ), static_cast<VkDeviceSize>( missShaderBindingStride ), static_cast<VkBuffer>( hitShaderBindingTableBuffer ), static_cast<VkDeviceSize>( hitShaderBindingOffset ), static_cast<VkDeviceSize>( hitShaderBindingStride ), static_cast<VkBuffer>( callableShaderBindingTableBuffer ), static_cast<VkDeviceSize>( callableShaderBindingOffset ), static_cast<VkDeviceSize>( callableShaderBindingStride ), width, height, depth );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d ) const
+  {
+    d.vkCmdTraceRaysNV( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), static_cast<VkDeviceSize>( raygenShaderBindingOffset ), static_cast<VkBuffer>( missShaderBindingTableBuffer ), static_cast<VkDeviceSize>( missShaderBindingOffset ), static_cast<VkDeviceSize>( missShaderBindingStride ), static_cast<VkBuffer>( hitShaderBindingTableBuffer ), static_cast<VkDeviceSize>( hitShaderBindingOffset ), static_cast<VkDeviceSize>( hitShaderBindingStride ), static_cast<VkBuffer>( callableShaderBindingTableBuffer ), static_cast<VkDeviceSize>( callableShaderBindingOffset ), static_cast<VkDeviceSize>( callableShaderBindingStride ), width, height, depth );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d) const
+  {
+    d.vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( dataSize ), pData );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename T, typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d ) const
+  {
+    d.vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), data.size() * sizeof( T ) , reinterpret_cast<const void*>( data.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const
+  {
+    d.vkCmdWaitEvents( m_commandBuffer, eventCount, reinterpret_cast<const VkEvent*>( pEvents ), static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>( pImageMemoryBarriers ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d ) const
+  {
+    d.vkCmdWaitEvents( m_commandBuffer, events.size() , reinterpret_cast<const VkEvent*>( events.data() ), static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), memoryBarriers.size() , reinterpret_cast<const VkMemoryBarrier*>( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast<const VkBufferMemoryBarrier*>( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast<const VkImageMemoryBarrier*>( imageMemoryBarriers.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -39825,2070 +46850,208 @@ public:
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d) const
   {
-    d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast<const VkAccelerationStructureInfoNV*>( pInfo ), static_cast<VkBuffer>( instanceData ), instanceOffset, update, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkBuffer>( scratch ), scratchOffset );
+    d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), marker );
   }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+#else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d ) const
   {
-    d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast<const VkAccelerationStructureInfoNV*>( &info ), static_cast<VkBuffer>( instanceData ), instanceOffset, update, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkBuffer>( scratch ), scratchOffset );
+    d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), marker );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d) const
+  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d) const
   {
-    d.vkCmdTraceRaysNV( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), raygenShaderBindingOffset, static_cast<VkBuffer>( missShaderBindingTableBuffer ), missShaderBindingOffset, missShaderBindingStride, static_cast<VkBuffer>( hitShaderBindingTableBuffer ), hitShaderBindingOffset, hitShaderBindingStride, static_cast<VkBuffer>( callableShaderBindingTableBuffer ), callableShaderBindingOffset, callableShaderBindingStride, width, height, depth );
+    d.vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d ) const
   {
-    d.vkCmdTraceRaysNV( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), raygenShaderBindingOffset, static_cast<VkBuffer>( missShaderBindingTableBuffer ), missShaderBindingOffset, missShaderBindingStride, static_cast<VkBuffer>( hitShaderBindingTableBuffer ), hitShaderBindingOffset, hitShaderBindingStride, static_cast<VkBuffer>( callableShaderBindingTableBuffer ), callableShaderBindingOffset, callableShaderBindingStride, width, height, depth );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  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 )
-      : waitSemaphoreCount( waitSemaphoreCount_ )
-      , pWaitSemaphores( pWaitSemaphores_ )
-      , pWaitDstStageMask( pWaitDstStageMask_ )
-      , commandBufferCount( commandBufferCount_ )
-      , pCommandBuffers( pCommandBuffers_ )
-      , signalSemaphoreCount( signalSemaphoreCount_ )
-      , pSignalSemaphores( pSignalSemaphores_ )
-    {
-    }
-
-    SubmitInfo( VkSubmitInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubmitInfo ) );
-    }
-
-    SubmitInfo& operator=( VkSubmitInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubmitInfo ) );
-      return *this;
-    }
-    SubmitInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SubmitInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
-    {
-      waitSemaphoreCount = waitSemaphoreCount_;
-      return *this;
-    }
-
-    SubmitInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
-    {
-      pWaitSemaphores = pWaitSemaphores_;
-      return *this;
-    }
-
-    SubmitInfo& setPWaitDstStageMask( const PipelineStageFlags* pWaitDstStageMask_ )
-    {
-      pWaitDstStageMask = pWaitDstStageMask_;
-      return *this;
-    }
-
-    SubmitInfo& setCommandBufferCount( uint32_t commandBufferCount_ )
-    {
-      commandBufferCount = commandBufferCount_;
-      return *this;
-    }
-
-    SubmitInfo& setPCommandBuffers( const CommandBuffer* pCommandBuffers_ )
-    {
-      pCommandBuffers = pCommandBuffers_;
-      return *this;
-    }
-
-    SubmitInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
-    {
-      signalSemaphoreCount = signalSemaphoreCount_;
-      return *this;
-    }
-
-    SubmitInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
-    {
-      pSignalSemaphores = pSignalSemaphores_;
-      return *this;
-    }
-
-    operator VkSubmitInfo const&() const
-    {
-      return *reinterpret_cast<const VkSubmitInfo*>(this);
-    }
-
-    operator VkSubmitInfo &()
-    {
-      return *reinterpret_cast<VkSubmitInfo*>(this);
-    }
-
-    bool operator==( SubmitInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
-          && ( pWaitSemaphores == rhs.pWaitSemaphores )
-          && ( pWaitDstStageMask == rhs.pWaitDstStageMask )
-          && ( commandBufferCount == rhs.commandBufferCount )
-          && ( pCommandBuffers == rhs.pCommandBuffers )
-          && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
-          && ( pSignalSemaphores == rhs.pSignalSemaphores );
-    }
-
-    bool operator!=( SubmitInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSubmitInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreCount;
-    const Semaphore* pWaitSemaphores;
-    const PipelineStageFlags* pWaitDstStageMask;
-    uint32_t commandBufferCount;
-    const CommandBuffer* pCommandBuffers;
-    uint32_t signalSemaphoreCount;
-    const Semaphore* pSignalSemaphores;
-  };
-  static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" );
-
-  class Queue
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Queue()
-      : m_queue(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t )
-      : m_queue(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue )
-      : m_queue( queue )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Queue & operator=(VkQueue queue)
-    {
-      m_queue = queue;
-      return *this; 
-    }
-#endif
-
-    Queue & operator=( std::nullptr_t )
-    {
-      m_queue = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Queue const & rhs ) const
-    {
-      return m_queue == rhs.m_queue;
-    }
-
-    bool operator!=(Queue const & rhs ) const
-    {
-      return m_queue != rhs.m_queue;
-    }
-
-    bool operator<(Queue const & rhs ) const
-    {
-      return m_queue < rhs.m_queue;
-    }
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type submit( ArrayProxy<const SubmitInfo> submits, Fence fence, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result waitIdle(Dispatch const &d = Dispatch() ) const;
-#else
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type waitIdle(Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getCheckpointDataNV( uint32_t* pCheckpointDataCount, CheckpointDataNV* pCheckpointData, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<CheckpointDataNV>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<CheckpointDataNV,Allocator> getCheckpointDataNV(Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<CheckpointDataNV>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<CheckpointDataNV,Allocator> getCheckpointDataNV(Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const
-    {
-      return m_queue;
-    }
-
-    explicit operator bool() const
-    {
-      return m_queue != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_queue == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkQueue m_queue;
-  };
-
-  static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" );
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkQueueSubmit( m_queue, submitCount, reinterpret_cast<const VkSubmitInfo*>( pSubmits ), static_cast<VkFence>( fence ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::submit( ArrayProxy<const SubmitInfo> submits, Fence fence, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkQueueSubmit( m_queue, submits.size() , reinterpret_cast<const VkSubmitInfo*>( submits.data() ), static_cast<VkFence>( fence ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::submit" );
+    d.vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Queue::waitIdle(Dispatch const &d) const
+  VULKAN_HPP_INLINE Result CommandBuffer::end(Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkQueueWaitIdle( m_queue ) );
+    return static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::waitIdle(Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::end(Dispatch const &d ) const
   {
-    Result result = static_cast<Result>( d.vkQueueWaitIdle( m_queue ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::waitIdle" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Queue::bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkQueueBindSparse( m_queue, bindInfoCount, reinterpret_cast<const VkBindSparseInfo*>( pBindInfo ), static_cast<VkFence>( fence ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkQueueBindSparse( m_queue, bindInfo.size() , reinterpret_cast<const VkBindSparseInfo*>( bindInfo.data() ), static_cast<VkFence>( fence ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::bindSparse" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( pPresentInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( &presentInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
-  {
-    d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const
-  {
-    d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( &labelInfo ) );
+    Result result = static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::end" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT(Dispatch const &d) const
+  VULKAN_HPP_INLINE Result CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const &d) const
   {
-    d.vkQueueEndDebugUtilsLabelEXT( m_queue );
+    return static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT(Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const &d ) const
   {
-    d.vkQueueEndDebugUtilsLabelEXT( m_queue );
+    Result result = static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::reset" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d) const
   {
-    d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
+    return static_cast<Result>( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR*>( pAcquireInfo ), pImageIndex ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const &d ) const
   {
-    d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( &labelInfo ) );
+    uint32_t imageIndex;
+    Result result = static_cast<Result>( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR*>( &acquireInfo ), &imageIndex ) );
+    return createResultValue( result, imageIndex, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireNextImage2KHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t* pCheckpointDataCount, CheckpointDataNV* pCheckpointData, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d) const
   {
-    d.vkGetQueueCheckpointDataNV( m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV*>( pCheckpointData ) );
+    return static_cast<Result>( d.vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), pImageIndex ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<CheckpointDataNV,Allocator> Queue::getCheckpointDataNV(Dispatch const &d ) const
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d ) const
   {
-    std::vector<CheckpointDataNV,Allocator> checkpointData;
-    uint32_t checkpointDataCount;
-    d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
-    checkpointData.resize( checkpointDataCount );
-    d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV*>( checkpointData.data() ) );
-    return checkpointData;
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<CheckpointDataNV,Allocator> Queue::getCheckpointDataNV(Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<CheckpointDataNV,Allocator> checkpointData( vectorAllocator );
-    uint32_t checkpointDataCount;
-    d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
-    checkpointData.resize( checkpointDataCount );
-    d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV*>( checkpointData.data() ) );
-    return checkpointData;
+    uint32_t imageIndex;
+    Result result = static_cast<Result>( d.vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), &imageIndex ) );
+    return createResultValue( result, imageIndex, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireNextImageKHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkCommandBuffer*>( pCommandBuffers ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d ) const
+  {
+    std::vector<CommandBuffer,Allocator> commandBuffers( allocateInfo.commandBufferCount );
+    Result result = static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( commandBuffers.data() ) ) );
+    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateCommandBuffers" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<CommandBuffer,Allocator> commandBuffers( allocateInfo.commandBufferCount, vectorAllocator );
+    Result result = static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( commandBuffers.data() ) ) );
+    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateCommandBuffers" );
+  }
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
-  class Device;
-
-  template <typename Dispatch> class UniqueHandleTraits<AccelerationStructureNV,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<Buffer,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueBuffer = UniqueHandle<Buffer,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<BufferView,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueBufferView = UniqueHandle<BufferView,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<CommandBuffer,Dispatch> {public: using deleter = PoolFree<Device, CommandPool,Dispatch>; };
-  using UniqueCommandBuffer = UniqueHandle<CommandBuffer,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<CommandPool,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueCommandPool = UniqueHandle<CommandPool,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<DescriptorPool,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueDescriptorPool = UniqueHandle<DescriptorPool,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<DescriptorSet,Dispatch> {public: using deleter = PoolFree<Device, DescriptorPool,Dispatch>; };
-  using UniqueDescriptorSet = UniqueHandle<DescriptorSet,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<DescriptorSetLayout,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<DescriptorUpdateTemplate,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueDescriptorUpdateTemplate = UniqueHandle<DescriptorUpdateTemplate,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<DeviceMemory,Dispatch> {public: using deleter = ObjectFree<Device,Dispatch>; };
-  using UniqueDeviceMemory = UniqueHandle<DeviceMemory,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<Event,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueEvent = UniqueHandle<Event,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<Fence,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueFence = UniqueHandle<Fence,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<Framebuffer,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueFramebuffer = UniqueHandle<Framebuffer,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<Image,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueImage = UniqueHandle<Image,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<ImageView,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueImageView = UniqueHandle<ImageView,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<IndirectCommandsLayoutNVX,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueIndirectCommandsLayoutNVX = UniqueHandle<IndirectCommandsLayoutNVX,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<ObjectTableNVX,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueObjectTableNVX = UniqueHandle<ObjectTableNVX,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<Pipeline,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniquePipeline = UniqueHandle<Pipeline,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<PipelineCache,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniquePipelineCache = UniqueHandle<PipelineCache,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<PipelineLayout,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniquePipelineLayout = UniqueHandle<PipelineLayout,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<QueryPool,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueQueryPool = UniqueHandle<QueryPool,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<RenderPass,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueRenderPass = UniqueHandle<RenderPass,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<Sampler,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueSampler = UniqueHandle<Sampler,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<SamplerYcbcrConversion,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<Semaphore,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueSemaphore = UniqueHandle<Semaphore,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<ShaderModule,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueShaderModule = UniqueHandle<ShaderModule,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<SwapchainKHR,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<ValidationCacheEXT,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
-  using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT,DispatchLoaderStatic>;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  class Device
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d ) const
   {
-  public:
-    VULKAN_HPP_CONSTEXPR Device()
-      : m_device(VK_NULL_HANDLE)
-    {}
+    static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueHandle<CommandBuffer, Dispatch> ), "CommandBuffer is greater than UniqueHandle<CommandBuffer, Dispatch>!" );
+    std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator> commandBuffers;
+    commandBuffers.reserve( allocateInfo.commandBufferCount );
+    CommandBuffer* buffer = reinterpret_cast<CommandBuffer*>( reinterpret_cast<char*>( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueHandle<CommandBuffer, Dispatch> ) - sizeof( CommandBuffer ) ) );
+    Result result = static_cast<Result>(d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( buffer ) ) );
 
-    VULKAN_HPP_CONSTEXPR Device( std::nullptr_t )
-      : m_device(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device )
-      : m_device( device )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Device & operator=(VkDevice device)
+    PoolFree<Device,CommandPool,Dispatch> deleter( *this, allocateInfo.commandPool, d );
+    for ( size_t i=0 ; i<allocateInfo.commandBufferCount ; i++ )
     {
-      m_device = device;
-      return *this; 
-    }
-#endif
-
-    Device & operator=( std::nullptr_t )
-    {
-      m_device = VK_NULL_HANDLE;
-      return *this;
+      commandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( buffer[i], deleter ) );
     }
 
-    bool operator==( Device const & rhs ) const
+    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueHandle<CommandBuffer, Dispatch> ), "CommandBuffer is greater than UniqueHandle<CommandBuffer, Dispatch>!" );
+    std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator> commandBuffers( vectorAllocator );
+    commandBuffers.reserve( allocateInfo.commandBufferCount );
+    CommandBuffer* buffer = reinterpret_cast<CommandBuffer*>( reinterpret_cast<char*>( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueHandle<CommandBuffer, Dispatch> ) - sizeof( CommandBuffer ) ) );
+    Result result = static_cast<Result>(d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( buffer ) ) );
+
+    PoolFree<Device,CommandPool,Dispatch> deleter( *this, allocateInfo.commandPool, d );
+    for ( size_t i=0 ; i<allocateInfo.commandBufferCount ; i++ )
     {
-      return m_device == rhs.m_device;
+      commandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( buffer[i], deleter ) );
     }
 
-    bool operator!=(Device const & rhs ) const
+    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkDescriptorSet*>( pDescriptorSets ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d ) const
+  {
+    std::vector<DescriptorSet,Allocator> descriptorSets( allocateInfo.descriptorSetCount );
+    Result result = static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( descriptorSets.data() ) ) );
+    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateDescriptorSets" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<DescriptorSet,Allocator> descriptorSets( allocateInfo.descriptorSetCount, vectorAllocator );
+    Result result = static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( descriptorSets.data() ) ) );
+    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateDescriptorSets" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d ) const
+  {
+    static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueHandle<DescriptorSet, Dispatch> ), "DescriptorSet is greater than UniqueHandle<DescriptorSet, Dispatch>!" );
+    std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator> descriptorSets;
+    descriptorSets.reserve( allocateInfo.descriptorSetCount );
+    DescriptorSet* buffer = reinterpret_cast<DescriptorSet*>( reinterpret_cast<char*>( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueHandle<DescriptorSet, Dispatch> ) - sizeof( DescriptorSet ) ) );
+    Result result = static_cast<Result>(d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( buffer ) ) );
+
+    PoolFree<Device,DescriptorPool,Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
+    for ( size_t i=0 ; i<allocateInfo.descriptorSetCount ; i++ )
     {
-      return m_device != rhs.m_device;
+      descriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( buffer[i], deleter ) );
     }
 
-    bool operator<(Device const & rhs ) const
+    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueHandle<DescriptorSet, Dispatch> ), "DescriptorSet is greater than UniqueHandle<DescriptorSet, Dispatch>!" );
+    std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator> descriptorSets( vectorAllocator );
+    descriptorSets.reserve( allocateInfo.descriptorSetCount );
+    DescriptorSet* buffer = reinterpret_cast<DescriptorSet*>( reinterpret_cast<char*>( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueHandle<DescriptorSet, Dispatch> ) - sizeof( DescriptorSet ) ) );
+    Result result = static_cast<Result>(d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( buffer ) ) );
+
+    PoolFree<Device,DescriptorPool,Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
+    for ( size_t i=0 ; i<allocateInfo.descriptorSetCount ; i++ )
     {
-      return m_device < rhs.m_device;
+      descriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( buffer[i], deleter ) );
     }
 
-    template<typename Dispatch = DispatchLoaderStatic>
-    PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result waitIdle(Dispatch const &d = Dispatch() ) const;
-#else
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type waitIdle(Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<DeviceMemory>::type allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<DeviceMemory,Dispatch>>::type allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void free( DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void*>::type mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags = MemoryMapFlags(), Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void unmapMemory( DeviceMemory memory, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    DeviceSize getMemoryCommitment( DeviceMemory memory, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    MemoryRequirements getBufferMemoryRequirements( Buffer buffer, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
-#else
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    MemoryRequirements getImageMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
-#else
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Fence>::type createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type resetFences( ArrayProxy<const Fence> fences, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getFenceStatus( Fence fence, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Semaphore>::type createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<Semaphore,Dispatch>>::type createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Event>::type createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<Event,Dispatch>>::type createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyEvent( Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getEventStatus( Event event, Dispatch const &d = Dispatch() ) const;
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result setEvent( Event event, Dispatch const &d = Dispatch() ) const;
-#else
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type setEvent( Event event, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result resetEvent( Event event, Dispatch const &d = Dispatch() ) const;
-#else
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type resetEvent( Event event, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<QueryPool>::type createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<QueryPool,Dispatch>>::type createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T, typename Dispatch = DispatchLoaderStatic>
-    Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Buffer>::type createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<Buffer,Dispatch>>::type createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<BufferView>::type createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<BufferView,Dispatch>>::type createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Image>::type createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<Image,Dispatch>>::type createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyImage( Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    SubresourceLayout getImageSubresourceLayout( Image image, const ImageSubresource & subresource, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<ImageView>::type createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<ImageView,Dispatch>>::type createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<ShaderModule>::type createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<ShaderModule,Dispatch>>::type createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<PipelineCache>::type createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<PipelineCache,Dispatch>>::type createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Pipeline>::type createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Pipeline>::type createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<PipelineLayout>::type createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<PipelineLayout,Dispatch>>::type createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Sampler>::type createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<Sampler,Dispatch>>::type createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<DescriptorSetLayout>::type createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<DescriptorSetLayout,Dispatch>>::type createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<DescriptorPool>::type createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<DescriptorPool,Dispatch>>::type createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const;
-#else
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<DescriptorSet>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<DescriptorSet>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<UniqueDescriptorSet>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<UniqueDescriptorSet>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type free( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Framebuffer>::type createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<Framebuffer,Dispatch>>::type createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<RenderPass>::type createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Extent2D getRenderAreaGranularity( RenderPass renderPass, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<CommandPool>::type createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<CommandPool,Dispatch>>::type createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const;
-#else
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<UniqueCommandBuffer>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<UniqueCommandBuffer>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void free( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SwapchainKHR>::type createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<Image>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<Image>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValue<uint32_t> acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<HANDLE>::type getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<IndirectCommandsLayoutNVX>::type createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNVX,Dispatch>>::type createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<ObjectTableNVX>::type createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<ObjectTableNVX,Dispatch>>::type createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyObjectTableNVX( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<HANDLE>::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<int>::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<int>::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<HANDLE>::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<int>::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Fence>::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Fence>::type registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<uint64_t>::type getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result bindBufferMemory2( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type bindBufferMemory2( ArrayProxy<const BindBufferMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type bindBufferMemory2KHR( ArrayProxy<const BindBufferMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result bindImageMemory2( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type bindImageMemory2( ArrayProxy<const BindImageMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type bindImageMemory2KHR( ArrayProxy<const BindImageMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<DeviceGroupPresentCapabilitiesKHR>::type getGroupPresentCapabilitiesKHR(Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValue<uint32_t> acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<DescriptorUpdateTemplate>::type createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<DescriptorUpdateTemplate>::type createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> swapchains, ArrayProxy<const HdrMetadataEXT> metadata, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<RefreshCycleDurationGOOGLE>::type getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    MemoryRequirements2 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<X, Y, Z...> getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    MemoryRequirements2 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    MemoryRequirements2 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<X, Y, Z...> getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    MemoryRequirements2 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SamplerYcbcrConversion>::type createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SamplerYcbcrConversion>::type createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Queue getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<ValidationCacheEXT>::type createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<ValidationCacheEXT,Dispatch>>::type createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> srcCaches, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<uint64_t>::type getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createRenderPass2KHR( const RenderPassCreateInfo2KHR* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<RenderPass>::type createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type createRenderPass2KHRUnique( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<StructureChain<X, Y, Z...>>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<struct AHardwareBuffer*>::type getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
-#else
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<AccelerationStructureNV>::type createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<AccelerationStructureNV,Dispatch>>::type createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type bindAccelerationStructureMemoryNV( ArrayProxy<const BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T, typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T, typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Pipeline>::type createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getImageDrmFormatModifierPropertiesEXT( Image image, ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const
-    {
-      return m_device;
-    }
-
-    explicit operator bool() const
-    {
-      return m_device != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_device == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDevice m_device;
-  };
-
-  static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" );
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char* pName, Dispatch const &d) const
-  {
-    return d.vkGetDeviceProcAddr( m_device, pName );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name, Dispatch const &d ) const
-  {
-    return d.vkGetDeviceProcAddr( m_device, name.c_str() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d) const
-  {
-    d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( pQueue ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d ) const
-  {
-    Queue queue;
-    d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( &queue ) );
-    return queue;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::waitIdle(Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkDeviceWaitIdle( m_device ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::waitIdle(Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkDeviceWaitIdle( m_device ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitIdle" );
+    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
   }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
@@ -41918,115 +47081,16 @@ public:
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d) const
   {
-    d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+    return static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>( pBindInfos ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindAccelerationStructureMemoryNV( ArrayProxy<const BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d ) const
   {
-    d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::free( DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), offset, size, static_cast<VkMemoryMapFlags>( flags ), ppData ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void*>::type Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, Dispatch const &d ) const
-  {
-    void* pData;
-    Result result = static_cast<Result>( d.vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), offset, size, static_cast<VkMemoryMapFlags>( flags ), &pData ) );
-    return createResultValue( result, pData, VULKAN_HPP_NAMESPACE_STRING"::Device::mapMemory" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d) const
-  {
-    d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d ) const
-  {
-    d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkFlushMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::flushMappedMemoryRanges" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkInvalidateMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::invalidateMappedMemoryRanges" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d) const
-  {
-    d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), pCommittedMemoryInBytes );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE DeviceSize Device::getMemoryCommitment( DeviceMemory memory, Dispatch const &d ) const
-  {
-    DeviceSize committedMemoryInBytes;
-    d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), &committedMemoryInBytes );
-    return committedMemoryInBytes;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements, Dispatch const &d) const
-  {
-    d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements Device::getBufferMemoryRequirements( Buffer buffer, Dispatch const &d ) const
-  {
-    MemoryRequirements memoryRequirements;
-    d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
-    return memoryRequirements;
+    Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfos.size() , reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>( bindInfos.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindAccelerationStructureMemoryNV" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -42034,2235 +47098,17 @@ public:
   template<typename Dispatch>
   VULKAN_HPP_INLINE Result Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
+    return static_cast<Result>( d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
   }
 #else
   template<typename Dispatch>
   VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d ) const
   {
-    Result result = static_cast<Result>( d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
+    Result result = static_cast<Result>( d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d) const
-  {
-    d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements Device::getImageMemoryRequirements( Image image, Dispatch const &d ) const
-  {
-    MemoryRequirements memoryRequirements;
-    d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d) const
-  {
-    d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( pSparseMemoryRequirements ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( Image image, Dispatch const &d ) const
-  {
-    std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements;
-    uint32_t sparseMemoryRequirementCount;
-    d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( sparseMemoryRequirements.data() ) );
-    return sparseMemoryRequirements;
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements( vectorAllocator );
-    uint32_t sparseMemoryRequirementCount;
-    d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( sparseMemoryRequirements.data() ) );
-    return sparseMemoryRequirements;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Fence fence;
-    Result result = static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
-    return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::createFence" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type Device::createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Fence fence;
-    Result result = static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Fence,Dispatch>( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::createFenceUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkResetFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetFences( ArrayProxy<const Fence> fences, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkResetFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetFences" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceStatus", { Result::eSuccess, Result::eNotReady } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkWaitForFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ), waitAll, timeout ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkWaitForFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ), waitAll, timeout ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitForFences", { Result::eSuccess, Result::eTimeout } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSemaphore*>( pSemaphore ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Semaphore>::type Device::createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Semaphore semaphore;
-    Result result = static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) );
-    return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING"::Device::createSemaphore" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Semaphore,Dispatch>>::type Device::createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Semaphore semaphore;
-    Result result = static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Semaphore,Dispatch>( result, semaphore, VULKAN_HPP_NAMESPACE_STRING"::Device::createSemaphoreUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkEvent*>( pEvent ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Event>::type Device::createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Event event;
-    Result result = static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) );
-    return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING"::Device::createEvent" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Event,Dispatch>>::type Device::createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Event event;
-    Result result = static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Event,Dispatch>( result, event, VULKAN_HPP_NAMESPACE_STRING"::Device::createEventUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyEvent( Event event, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Event event, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getEventStatus", { Result::eEventSet, Result::eEventReset } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::setEvent( Event event, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::setEvent( Event event, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::setEvent" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::resetEvent( Event event, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetEvent( Event event, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetEvent" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkQueryPool*>( pQueryPool ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<QueryPool>::type Device::createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    QueryPool queryPool;
-    Result result = static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) );
-    return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createQueryPool" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<QueryPool,Dispatch>>::type Device::createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    QueryPool queryPool;
-    Result result = static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<QueryPool,Dispatch>( result, queryPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createQueryPoolUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, dataSize, pData, stride, static_cast<VkQueryResultFlags>( flags ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ), stride, static_cast<VkQueryResultFlags>( flags ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBuffer*>( pBuffer ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Buffer>::type Device::createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Buffer buffer;
-    Result result = static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) );
-    return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createBuffer" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Buffer,Dispatch>>::type Device::createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Buffer buffer;
-    Result result = static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Buffer,Dispatch>( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBufferView*>( pView ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<BufferView>::type Device::createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    BufferView view;
-    Result result = static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) );
-    return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferView" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<BufferView,Dispatch>>::type Device::createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    BufferView view;
-    Result result = static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<BufferView,Dispatch>( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferViewUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImage*>( pImage ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Image>::type Device::createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Image image;
-    Result result = static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) );
-    return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING"::Device::createImage" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Image,Dispatch>>::type Device::createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Image image;
-    Result result = static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Image,Dispatch>( result, image, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyImage( Image image, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Image image, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d) const
-  {
-    d.vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( pSubresource ), reinterpret_cast<VkSubresourceLayout*>( pLayout ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE SubresourceLayout Device::getImageSubresourceLayout( Image image, const ImageSubresource & subresource, Dispatch const &d ) const
-  {
-    SubresourceLayout layout;
-    d.vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( &subresource ), reinterpret_cast<VkSubresourceLayout*>( &layout ) );
-    return layout;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImageView*>( pView ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ImageView>::type Device::createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    ImageView view;
-    Result result = static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) );
-    return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageView" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ImageView,Dispatch>>::type Device::createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    ImageView view;
-    Result result = static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<ImageView,Dispatch>( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageViewUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkShaderModule*>( pShaderModule ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ShaderModule>::type Device::createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    ShaderModule shaderModule;
-    Result result = static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) );
-    return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING"::Device::createShaderModule" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ShaderModule,Dispatch>>::type Device::createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    ShaderModule shaderModule;
-    Result result = static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<ShaderModule,Dispatch>( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING"::Device::createShaderModuleUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineCache*>( pPipelineCache ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<PipelineCache>::type Device::createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    PipelineCache pipelineCache;
-    Result result = static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) );
-    return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineCache" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PipelineCache,Dispatch>>::type Device::createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    PipelineCache pipelineCache;
-    Result result = static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<PipelineCache,Dispatch>( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineCacheUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), pDataSize, pData ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d ) const
-  {
-    std::vector<uint8_t,Allocator> data;
-    size_t dataSize;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
-      if ( ( result == Result::eSuccess ) && dataSize )
-      {
-        data.resize( dataSize );
-        result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( dataSize <= data.size() );
-      data.resize( dataSize );
-    }
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineCacheData" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<uint8_t,Allocator> data( vectorAllocator );
-    size_t dataSize;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
-      if ( ( result == Result::eSuccess ) && dataSize )
-      {
-        data.resize( dataSize );
-        result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( dataSize <= data.size() );
-      data.resize( dataSize );
-    }
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineCacheData" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCacheCount, reinterpret_cast<const VkPipelineCache*>( pSrcCaches ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCaches.size() , reinterpret_cast<const VkPipelineCache*>( srcCaches.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergePipelineCaches" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
-    Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
-    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
-    Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
-    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" );
-  }
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Pipeline pipeline;
-    Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
-    return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipeline" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
-    std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
-    pipelines.reserve( createInfos.size() );
-    Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
-    Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    for ( size_t i=0 ; i<createInfos.size() ; i++ )
-    {
-      pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
-    }
-
-    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
-    std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
-    pipelines.reserve( createInfos.size() );
-    Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
-    Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    for ( size_t i=0 ; i<createInfos.size() ; i++ )
-    {
-      pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
-    }
-
-    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" );
-  }
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Pipeline pipeline;
-    Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Pipeline,Dispatch>( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelineUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkComputePipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
-    Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
-    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
-    Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
-    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" );
-  }
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Pipeline pipeline;
-    Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkComputePipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
-    return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipeline" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
-    std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
-    pipelines.reserve( createInfos.size() );
-    Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
-    Result result = static_cast<Result>(d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    for ( size_t i=0 ; i<createInfos.size() ; i++ )
-    {
-      pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
-    }
-
-    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
-    std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
-    pipelines.reserve( createInfos.size() );
-    Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
-    Result result = static_cast<Result>(d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    for ( size_t i=0 ; i<createInfos.size() ; i++ )
-    {
-      pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
-    }
-
-    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" );
-  }
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Pipeline pipeline;
-    Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkComputePipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Pipeline,Dispatch>( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelineUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineLayout*>( pPipelineLayout ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<PipelineLayout>::type Device::createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    PipelineLayout pipelineLayout;
-    Result result = static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) );
-    return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineLayout" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PipelineLayout,Dispatch>>::type Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    PipelineLayout pipelineLayout;
-    Result result = static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<PipelineLayout,Dispatch>( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineLayoutUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSampler*>( pSampler ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Sampler>::type Device::createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Sampler sampler;
-    Result result = static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) );
-    return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING"::Device::createSampler" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Sampler,Dispatch>>::type Device::createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Sampler sampler;
-    Result result = static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Sampler,Dispatch>( result, sampler, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorSetLayout*>( pSetLayout ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DescriptorSetLayout>::type Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    DescriptorSetLayout setLayout;
-    Result result = static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) );
-    return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorSetLayout" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorSetLayout,Dispatch>>::type Device::createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    DescriptorSetLayout setLayout;
-    Result result = static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<DescriptorSetLayout,Dispatch>( result, setLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorSetLayoutUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorPool*>( pDescriptorPool ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DescriptorPool>::type Device::createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    DescriptorPool descriptorPool;
-    Result result = static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) );
-    return createResultValue( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorPool" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorPool,Dispatch>>::type Device::createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    DescriptorPool descriptorPool;
-    Result result = static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<DescriptorPool,Dispatch>( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorPoolUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetDescriptorPool" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkDescriptorSet*>( pDescriptorSets ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d ) const
-  {
-    std::vector<DescriptorSet,Allocator> descriptorSets( allocateInfo.descriptorSetCount );
-    Result result = static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( descriptorSets.data() ) ) );
-    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateDescriptorSets" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<DescriptorSet,Allocator> descriptorSets( allocateInfo.descriptorSetCount, vectorAllocator );
-    Result result = static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( descriptorSets.data() ) ) );
-    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateDescriptorSets" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d ) const
-  {
-    static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueHandle<DescriptorSet, Dispatch> ), "DescriptorSet is greater than UniqueHandle<DescriptorSet, Dispatch>!" );
-    std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator> descriptorSets;
-    descriptorSets.reserve( allocateInfo.descriptorSetCount );
-    DescriptorSet* buffer = reinterpret_cast<DescriptorSet*>( reinterpret_cast<char*>( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueHandle<DescriptorSet, Dispatch> ) - sizeof( DescriptorSet ) ) );
-    Result result = static_cast<Result>(d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( buffer ) ) );
-
-    PoolFree<Device,DescriptorPool,Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
-    for ( size_t i=0 ; i<allocateInfo.descriptorSetCount ; i++ )
-    {
-      descriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( buffer[i], deleter ) );
-    }
-
-    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueHandle<DescriptorSet, Dispatch> ), "DescriptorSet is greater than UniqueHandle<DescriptorSet, Dispatch>!" );
-    std::vector<UniqueHandle<DescriptorSet, Dispatch>, Allocator> descriptorSets( vectorAllocator );
-    descriptorSets.reserve( allocateInfo.descriptorSetCount );
-    DescriptorSet* buffer = reinterpret_cast<DescriptorSet*>( reinterpret_cast<char*>( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueHandle<DescriptorSet, Dispatch> ) - sizeof( DescriptorSet ) ) );
-    Result result = static_cast<Result>(d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( buffer ) ) );
-
-    PoolFree<Device,DescriptorPool,Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
-    for ( size_t i=0 ; i<allocateInfo.descriptorSetCount ; i++ )
-    {
-      descriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( buffer[i], deleter ) );
-    }
-
-    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::freeDescriptorSets" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::free( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::free" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d) const
-  {
-    d.vkUpdateDescriptorSets( m_device, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ), descriptorCopyCount, reinterpret_cast<const VkCopyDescriptorSet*>( pDescriptorCopies ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies, Dispatch const &d ) const
-  {
-    d.vkUpdateDescriptorSets( m_device, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ), descriptorCopies.size() , reinterpret_cast<const VkCopyDescriptorSet*>( descriptorCopies.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFramebuffer*>( pFramebuffer ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Framebuffer>::type Device::createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Framebuffer framebuffer;
-    Result result = static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) );
-    return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createFramebuffer" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Framebuffer,Dispatch>>::type Device::createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Framebuffer framebuffer;
-    Result result = static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Framebuffer,Dispatch>( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createFramebufferUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<RenderPass>::type Device::createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    RenderPass renderPass;
-    Result result = static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
-    return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type Device::createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    RenderPass renderPass;
-    Result result = static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<RenderPass,Dispatch>( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPassUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d) const
-  {
-    d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( pGranularity ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Extent2D Device::getRenderAreaGranularity( RenderPass renderPass, Dispatch const &d ) const
-  {
-    Extent2D granularity;
-    d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( &granularity ) );
-    return granularity;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkCommandPool*>( pCommandPool ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<CommandPool>::type Device::createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    CommandPool commandPool;
-    Result result = static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) );
-    return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createCommandPool" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<CommandPool,Dispatch>>::type Device::createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    CommandPool commandPool;
-    Result result = static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<CommandPool,Dispatch>( result, commandPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createCommandPoolUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetCommandPool" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkCommandBuffer*>( pCommandBuffers ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d ) const
-  {
-    std::vector<CommandBuffer,Allocator> commandBuffers( allocateInfo.commandBufferCount );
-    Result result = static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( commandBuffers.data() ) ) );
-    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateCommandBuffers" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<CommandBuffer,Allocator> commandBuffers( allocateInfo.commandBufferCount, vectorAllocator );
-    Result result = static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( commandBuffers.data() ) ) );
-    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateCommandBuffers" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d ) const
-  {
-    static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueHandle<CommandBuffer, Dispatch> ), "CommandBuffer is greater than UniqueHandle<CommandBuffer, Dispatch>!" );
-    std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator> commandBuffers;
-    commandBuffers.reserve( allocateInfo.commandBufferCount );
-    CommandBuffer* buffer = reinterpret_cast<CommandBuffer*>( reinterpret_cast<char*>( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueHandle<CommandBuffer, Dispatch> ) - sizeof( CommandBuffer ) ) );
-    Result result = static_cast<Result>(d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( buffer ) ) );
-
-    PoolFree<Device,CommandPool,Dispatch> deleter( *this, allocateInfo.commandPool, d );
-    for ( size_t i=0 ; i<allocateInfo.commandBufferCount ; i++ )
-    {
-      commandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( buffer[i], deleter ) );
-    }
-
-    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueHandle<CommandBuffer, Dispatch> ), "CommandBuffer is greater than UniqueHandle<CommandBuffer, Dispatch>!" );
-    std::vector<UniqueHandle<CommandBuffer, Dispatch>, Allocator> commandBuffers( vectorAllocator );
-    commandBuffers.reserve( allocateInfo.commandBufferCount );
-    CommandBuffer* buffer = reinterpret_cast<CommandBuffer*>( reinterpret_cast<char*>( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueHandle<CommandBuffer, Dispatch> ) - sizeof( CommandBuffer ) ) );
-    Result result = static_cast<Result>(d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( buffer ) ) );
-
-    PoolFree<Device,CommandPool,Dispatch> deleter( *this, allocateInfo.commandPool, d );
-    for ( size_t i=0 ; i<allocateInfo.commandBufferCount ; i++ )
-    {
-      commandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( buffer[i], deleter ) );
-    }
-
-    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
-  {
-    d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
-  {
-    d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
-  {
-    d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
-  {
-    d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, swapchainCount, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchains ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size() );
-    Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( swapchains.data() ) ) );
-    return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainsKHR" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size(), vectorAllocator );
-    Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( swapchains.data() ) ) );
-    return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainsKHR" );
-  }
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SwapchainKHR>::type Device::createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    SwapchainKHR swapchain;
-    Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
-    return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle<SwapchainKHR, Dispatch> ), "SwapchainKHR is greater than UniqueHandle<SwapchainKHR, Dispatch>!" );
-    std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> swapchainKHRs;
-    swapchainKHRs.reserve( createInfos.size() );
-    SwapchainKHR* buffer = reinterpret_cast<SwapchainKHR*>( reinterpret_cast<char*>( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueHandle<SwapchainKHR, Dispatch> ) - sizeof( SwapchainKHR ) ) );
-    Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( buffer ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    for ( size_t i=0 ; i<createInfos.size() ; i++ )
-    {
-      swapchainKHRs.push_back( UniqueHandle<SwapchainKHR, Dispatch>( buffer[i], deleter ) );
-    }
-
-    return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle<SwapchainKHR, Dispatch> ), "SwapchainKHR is greater than UniqueHandle<SwapchainKHR, Dispatch>!" );
-    std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> swapchainKHRs( vectorAllocator );
-    swapchainKHRs.reserve( createInfos.size() );
-    SwapchainKHR* buffer = reinterpret_cast<SwapchainKHR*>( reinterpret_cast<char*>( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueHandle<SwapchainKHR, Dispatch> ) - sizeof( SwapchainKHR ) ) );
-    Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( buffer ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    for ( size_t i=0 ; i<createInfos.size() ; i++ )
-    {
-      swapchainKHRs.push_back( UniqueHandle<SwapchainKHR, Dispatch>( buffer[i], deleter ) );
-    }
-
-    return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
-  }
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type Device::createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    SwapchainKHR swapchain;
-    Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SwapchainKHR,Dispatch>( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchain ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SwapchainKHR>::type Device::createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    SwapchainKHR swapchain;
-    Result result = static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
-    return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSwapchainKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    SwapchainKHR swapchain;
-    Result result = static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SwapchainKHR,Dispatch>( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSwapchainKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), pSwapchainImageCount, reinterpret_cast<VkImage*>( pSwapchainImages ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d ) const
-  {
-    std::vector<Image,Allocator> swapchainImages;
-    uint32_t swapchainImageCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && swapchainImageCount )
-      {
-        swapchainImages.resize( swapchainImageCount );
-        result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage*>( swapchainImages.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
-      swapchainImages.resize( swapchainImageCount );
-    }
-    return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainImagesKHR" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<Image,Allocator> swapchainImages( vectorAllocator );
-    uint32_t swapchainImageCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && swapchainImageCount )
-      {
-        swapchainImages.resize( swapchainImageCount );
-        result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage*>( swapchainImages.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
-      swapchainImages.resize( swapchainImageCount );
-    }
-    return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainImagesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), pImageIndex ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d ) const
-  {
-    uint32_t imageIndex;
-    Result result = static_cast<Result>( d.vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), &imageIndex ) );
-    return createResultValue( result, imageIndex, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireNextImageKHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( pNameInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( &nameInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::debugMarkerSetObjectNameEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( pTagInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( &tagInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::debugMarkerSetObjectTagEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), pHandle ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d ) const
-  {
-    HANDLE handle;
-    Result result = static_cast<Result>( d.vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle ) );
-    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandleNV" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( pIndirectCommandsLayout ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<IndirectCommandsLayoutNVX>::type Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    IndirectCommandsLayoutNVX indirectCommandsLayout;
-    Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) );
-    return createResultValue( result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createIndirectCommandsLayoutNVX" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNVX,Dispatch>>::type Device::createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    IndirectCommandsLayoutNVX indirectCommandsLayout;
-    Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<IndirectCommandsLayoutNVX,Dispatch>( result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createIndirectCommandsLayoutNVXUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkObjectTableNVX*>( pObjectTable ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ObjectTableNVX>::type Device::createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    ObjectTableNVX objectTable;
-    Result result = static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) );
-    return createResultValue( result, objectTable, VULKAN_HPP_NAMESPACE_STRING"::Device::createObjectTableNVX" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ObjectTableNVX,Dispatch>>::type Device::createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    ObjectTableNVX objectTable;
-    Result result = static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<ObjectTableNVX,Dispatch>( result, objectTable, VULKAN_HPP_NAMESPACE_STRING"::Device::createObjectTableNVXUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkRegisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectTableEntryNVX* const*>( ppObjectTableEntries ), pObjectIndices ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d ) const
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( pObjectTableEntries.size() == objectIndices.size() );
-#else
-    if ( pObjectTableEntries.size() != objectIndices.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::registerObjectsNVX: pObjectTableEntries.size() != objectIndices.size()" );
-    }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    Result result = static_cast<Result>( d.vkRegisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), pObjectTableEntries.size() , reinterpret_cast<const VkObjectTableEntryNVX* const*>( pObjectTableEntries.data() ), objectIndices.data() ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::registerObjectsNVX" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkUnregisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectEntryTypeNVX*>( pObjectEntryTypes ), pObjectIndices ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d ) const
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( objectEntryTypes.size() == objectIndices.size() );
-#else
-    if ( objectEntryTypes.size() != objectIndices.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::unregisterObjectsNVX: objectEntryTypes.size() != objectIndices.size()" );
-    }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    Result result = static_cast<Result>( d.vkUnregisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectEntryTypes.size() , reinterpret_cast<const VkObjectEntryTypeNVX*>( objectEntryTypes.data() ), objectIndices.data() ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::unregisterObjectsNVX" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const
-  {
-    d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d ) const
-  {
-    d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const
-  {
-    d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d ) const
-  {
-    d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const
-  {
-    HANDLE handle;
-    Result result = static_cast<Result>( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) );
-    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandleKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( pMemoryWin32HandleProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<MemoryWin32HandlePropertiesKHR>::type Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d ) const
-  {
-    MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
-    Result result = static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( &memoryWin32HandleProperties ) ) );
-    return createResultValue( result, memoryWin32HandleProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandlePropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<int>::type Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const &d ) const
-  {
-    int fd;
-    Result result = static_cast<Result>( d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR*>( &getFdInfo ), &fd ) );
-    return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( pMemoryFdProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<MemoryFdPropertiesKHR>::type Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d ) const
-  {
-    MemoryFdPropertiesKHR memoryFdProperties;
-    Result result = static_cast<Result>( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( &memoryFdProperties ) ) );
-    return createResultValue( result, memoryFdProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryFdPropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const
-  {
-    HANDLE handle;
-    Result result = static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) );
-    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getSemaphoreWin32HandleKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( pImportSemaphoreWin32HandleInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( &importSemaphoreWin32HandleInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importSemaphoreWin32HandleKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<int>::type Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const &d ) const
-  {
-    int fd;
-    Result result = static_cast<Result>( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( &getFdInfo ), &fd ) );
-    return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getSemaphoreFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( pImportSemaphoreFdInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( &importSemaphoreFdInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importSemaphoreFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const
-  {
-    HANDLE handle;
-    Result result = static_cast<Result>( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) );
-    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceWin32HandleKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( pImportFenceWin32HandleInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( &importFenceWin32HandleInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importFenceWin32HandleKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<int>::type Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const &d ) const
-  {
-    int fd;
-    Result result = static_cast<Result>( d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR*>( &getFdInfo ), &fd ) );
-    return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR*>( pImportFenceFdInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR*>( &importFenceFdInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importFenceFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( pDisplayPowerInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( &displayPowerInfo ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::displayPowerControlEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( pDeviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Fence fence;
-    Result result = static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( &deviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
-    return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerEventEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( pDisplayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Fence fence;
-    Result result = static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( &displayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
-    return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerDisplayEventEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), pCounterValue ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const &d ) const
-  {
-    uint64_t counterValue;
-    Result result = static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ) );
-    return createResultValue( result, counterValue, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainCounterEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
-  {
-    d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
-  {
-    PeerMemoryFeatureFlags peerMemoryFeatures;
-    d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
-    return peerMemoryFeatures;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
-  {
-    d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
-  {
-    PeerMemoryFeatureFlags peerMemoryFeatures;
-    d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
-    return peerMemoryFeatures;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
   template<typename Dispatch>
   VULKAN_HPP_INLINE Result Device::bindBufferMemory2( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const
   {
@@ -44291,6 +47137,21 @@ public:
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template<typename Dispatch>
   VULKAN_HPP_INLINE Result Device::bindImageMemory2( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d) const
   {
@@ -44319,49 +47180,249 @@ public:
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>( pDeviceGroupPresentCapabilities ) ) );
+    return static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
   }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+#else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentCapabilitiesKHR>::type Device::getGroupPresentCapabilitiesKHR(Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d ) const
   {
-    DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
-    Result result = static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>( &deviceGroupPresentCapabilities ) ) );
-    return createResultValue( result, deviceGroupPresentCapabilities, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupPresentCapabilitiesKHR" );
+    Result result = static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::compileDeferredNV" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( pModes ) ) );
+    return static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkAccelerationStructureNV*>( pAccelerationStructure ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentModeFlagsKHR>::type Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<AccelerationStructureNV>::type Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    DeviceGroupPresentModeFlagsKHR modes;
-    Result result = static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( &modes ) ) );
-    return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupSurfacePresentModesKHR" );
+    AccelerationStructureNV accelerationStructure;
+    Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNV*>( &accelerationStructure ) ) );
+    return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNV" );
   }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<AccelerationStructureNV,Dispatch>>::type Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    AccelerationStructureNV accelerationStructure;
+    Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNV*>( &accelerationStructure ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<AccelerationStructureNV,Dispatch>( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNVUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR*>( pAcquireInfo ), pImageIndex ) );
+    return static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBuffer*>( pBuffer ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<Buffer>::type Device::createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    uint32_t imageIndex;
-    Result result = static_cast<Result>( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR*>( &acquireInfo ), &imageIndex ) );
-    return createResultValue( result, imageIndex, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireNextImage2KHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } );
+    Buffer buffer;
+    Result result = static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) );
+    return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createBuffer" );
   }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Buffer,Dispatch>>::type Device::createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Buffer buffer;
+    Result result = static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Buffer,Dispatch>( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBufferView*>( pView ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<BufferView>::type Device::createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    BufferView view;
+    Result result = static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) );
+    return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferView" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<BufferView,Dispatch>>::type Device::createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    BufferView view;
+    Result result = static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<BufferView,Dispatch>( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferViewUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkCommandPool*>( pCommandPool ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<CommandPool>::type Device::createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    CommandPool commandPool;
+    Result result = static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) );
+    return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createCommandPool" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<CommandPool,Dispatch>>::type Device::createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    CommandPool commandPool;
+    Result result = static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<CommandPool,Dispatch>( result, commandPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createCommandPoolUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkComputePipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
+    Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
+    Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" );
+  }
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Pipeline pipeline;
+    Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkComputePipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
+    return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipeline" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
+    std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
+    pipelines.reserve( createInfos.size() );
+    Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
+    Result result = static_cast<Result>(d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    for ( size_t i=0 ; i<createInfos.size() ; i++ )
+    {
+      pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
+    }
+
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
+    std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
+    pipelines.reserve( createInfos.size() );
+    Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
+    Result result = static_cast<Result>(d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    for ( size_t i=0 ; i<createInfos.size() ; i++ )
+    {
+      pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
+    }
+
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" );
+  }
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Pipeline pipeline;
+    Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkComputePipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Pipeline,Dispatch>( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelineUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorPool*>( pDescriptorPool ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<DescriptorPool>::type Device::createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    DescriptorPool descriptorPool;
+    Result result = static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) );
+    return createResultValue( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorPool" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorPool,Dispatch>>::type Device::createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    DescriptorPool descriptorPool;
+    Result result = static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<DescriptorPool,Dispatch>( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorPoolUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorSetLayout*>( pSetLayout ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<DescriptorSetLayout>::type Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    DescriptorSetLayout setLayout;
+    Result result = static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) );
+    return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorSetLayout" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorSetLayout,Dispatch>>::type Device::createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    DescriptorSetLayout setLayout;
+    Result result = static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<DescriptorSetLayout,Dispatch>( result, setLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorSetLayoutUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
@@ -44417,321 +47478,489 @@ public:
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d) const
   {
-    d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+    return static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkEvent*>( pEvent ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<Event>::type Device::createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+    Event event;
+    Result result = static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) );
+    return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING"::Device::createEvent" );
   }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Event,Dispatch>>::type Device::createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Event event;
+    Result result = static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Event,Dispatch>( result, event, VULKAN_HPP_NAMESPACE_STRING"::Device::createEventUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
   {
-    d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+    return static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+    Fence fence;
+    Result result = static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
+    return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::createFence" );
   }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type Device::createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Fence fence;
+    Result result = static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Fence,Dispatch>( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::createFenceUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d) const
   {
-    d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+    return static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFramebuffer*>( pFramebuffer ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<Framebuffer>::type Device::createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+    Framebuffer framebuffer;
+    Result result = static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) );
+    return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createFramebuffer" );
   }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Framebuffer,Dispatch>>::type Device::createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Framebuffer framebuffer;
+    Result result = static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) );
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
-  {
-    d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
-  {
-    d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
-  {
-    d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
-  {
-    d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Framebuffer,Dispatch>( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createFramebufferUnique", deleter );
   }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
   {
-    d.vkSetHdrMetadataEXT( m_device, swapchainCount, reinterpret_cast<const VkSwapchainKHR*>( pSwapchains ), reinterpret_cast<const VkHdrMetadataEXT*>( pMetadata ) );
+    return static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> swapchains, ArrayProxy<const HdrMetadataEXT> metadata, Dispatch const &d ) const
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() );
-#else
-    if ( swapchains.size() != metadata.size() )
+    std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
+    Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
+    Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" );
+  }
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Pipeline pipeline;
+    Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
+    return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipeline" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
+    std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
+    pipelines.reserve( createInfos.size() );
+    Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
+    Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    for ( size_t i=0 ; i<createInfos.size() ; i++ )
     {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
+      pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
     }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    d.vkSetHdrMetadataEXT( m_device, swapchains.size() , reinterpret_cast<const VkSwapchainKHR*>( swapchains.data() ), reinterpret_cast<const VkHdrMetadataEXT*>( metadata.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" );
   }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d ) const
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
-    Result result = static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
+    std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
+    pipelines.reserve( createInfos.size() );
+    Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
+    Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
 
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( pDisplayTimingProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<RefreshCycleDurationGOOGLE>::type Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const &d ) const
-  {
-    RefreshCycleDurationGOOGLE displayTimingProperties;
-    Result result = static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( &displayTimingProperties ) ) );
-    return createResultValue( result, displayTimingProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getRefreshCycleDurationGOOGLE" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), pPresentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( pPresentationTimings ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const &d ) const
-  {
-    std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings;
-    uint32_t presentationTimingCount;
-    Result result;
-    do
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    for ( size_t i=0 ; i<createInfos.size() ; i++ )
     {
-      result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && presentationTimingCount )
-      {
-        presentationTimings.resize( presentationTimingCount );
-        result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( presentationTimings.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
-      presentationTimings.resize( presentationTimingCount );
+      pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
     }
-    return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING"::Device::getPastPresentationTimingGOOGLE" );
+
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" );
   }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings( vectorAllocator );
-    uint32_t presentationTimingCount;
-    Result result;
-    do
+    Pipeline pipeline;
+    Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Pipeline,Dispatch>( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelineUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImage*>( pImage ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<Image>::type Device::createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Image image;
+    Result result = static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) );
+    return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING"::Device::createImage" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Image,Dispatch>>::type Device::createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Image image;
+    Result result = static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Image,Dispatch>( result, image, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImageView*>( pView ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<ImageView>::type Device::createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    ImageView view;
+    Result result = static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) );
+    return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageView" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ImageView,Dispatch>>::type Device::createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    ImageView view;
+    Result result = static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<ImageView,Dispatch>( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageViewUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( pIndirectCommandsLayout ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<IndirectCommandsLayoutNVX>::type Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    IndirectCommandsLayoutNVX indirectCommandsLayout;
+    Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) );
+    return createResultValue( result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createIndirectCommandsLayoutNVX" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNVX,Dispatch>>::type Device::createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    IndirectCommandsLayoutNVX indirectCommandsLayout;
+    Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<IndirectCommandsLayoutNVX,Dispatch>( result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createIndirectCommandsLayoutNVXUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkObjectTableNVX*>( pObjectTable ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<ObjectTableNVX>::type Device::createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    ObjectTableNVX objectTable;
+    Result result = static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) );
+    return createResultValue( result, objectTable, VULKAN_HPP_NAMESPACE_STRING"::Device::createObjectTableNVX" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ObjectTableNVX,Dispatch>>::type Device::createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    ObjectTableNVX objectTable;
+    Result result = static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<ObjectTableNVX,Dispatch>( result, objectTable, VULKAN_HPP_NAMESPACE_STRING"::Device::createObjectTableNVXUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineCache*>( pPipelineCache ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<PipelineCache>::type Device::createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    PipelineCache pipelineCache;
+    Result result = static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) );
+    return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineCache" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PipelineCache,Dispatch>>::type Device::createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    PipelineCache pipelineCache;
+    Result result = static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<PipelineCache,Dispatch>( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineCacheUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineLayout*>( pPipelineLayout ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<PipelineLayout>::type Device::createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    PipelineLayout pipelineLayout;
+    Result result = static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) );
+    return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineLayout" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PipelineLayout,Dispatch>>::type Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    PipelineLayout pipelineLayout;
+    Result result = static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<PipelineLayout,Dispatch>( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineLayoutUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkQueryPool*>( pQueryPool ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<QueryPool>::type Device::createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    QueryPool queryPool;
+    Result result = static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) );
+    return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createQueryPool" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<QueryPool,Dispatch>>::type Device::createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    QueryPool queryPool;
+    Result result = static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<QueryPool,Dispatch>( result, queryPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createQueryPoolUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
+    Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
+    Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" );
+  }
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Pipeline pipeline;
+    Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
+    return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelineNV" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
+    std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
+    pipelines.reserve( createInfos.size() );
+    Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
+    Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    for ( size_t i=0 ; i<createInfos.size() ; i++ )
     {
-      result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && presentationTimingCount )
-      {
-        presentationTimings.resize( presentationTimingCount );
-        result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( presentationTimings.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
-      presentationTimings.resize( presentationTimingCount );
+      pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
     }
-    return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING"::Device::getPastPresentationTimingGOOGLE" );
+
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" );
   }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
+    std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
+    pipelines.reserve( createInfos.size() );
+    Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
+    Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    for ( size_t i=0 ; i<createInfos.size() ; i++ )
+    {
+      pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
+    }
+
+    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" );
+  }
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Pipeline pipeline;
+    Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Pipeline,Dispatch>( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelineNVUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d) const
   {
-    d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
+    return static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<RenderPass>::type Device::createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    MemoryRequirements2 memoryRequirements;
-    d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
-    return memoryRequirements;
+    RenderPass renderPass;
+    Result result = static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
+    return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass" );
   }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type Device::createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    StructureChain<X, Y, Z...> structureChain;
-    MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
-    d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
-    return structureChain;
+    RenderPass renderPass;
+    Result result = static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<RenderPass,Dispatch>( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPassUnique", deleter );
   }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createRenderPass2KHR( const RenderPassCreateInfo2KHR* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d) const
   {
-    d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
+    return static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<RenderPass>::type Device::createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    MemoryRequirements2 memoryRequirements;
-    d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
-    return memoryRequirements;
+    RenderPass renderPass;
+    Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
+    return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHR" );
   }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type Device::createRenderPass2KHRUnique( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    StructureChain<X, Y, Z...> structureChain;
-    MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
-    d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
-    return structureChain;
+    RenderPass renderPass;
+    Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<RenderPass,Dispatch>( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHRUnique", deleter );
   }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d) const
   {
-    d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
+    return static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSampler*>( pSampler ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<Sampler>::type Device::createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    MemoryRequirements2 memoryRequirements;
-    d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
-    return memoryRequirements;
+    Sampler sampler;
+    Result result = static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) );
+    return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING"::Device::createSampler" );
   }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Sampler,Dispatch>>::type Device::createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    StructureChain<X, Y, Z...> structureChain;
-    MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
-    d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+    Sampler sampler;
+    Result result = static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) );
 
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
-  {
-    d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
-  {
-    MemoryRequirements2 memoryRequirements;
-    d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
-  {
-    StructureChain<X, Y, Z...> structureChain;
-    MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
-    d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
-  {
-    d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d ) const
-  {
-    std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements;
-    uint32_t sparseMemoryRequirementCount;
-    d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
-    return sparseMemoryRequirements;
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements( vectorAllocator );
-    uint32_t sparseMemoryRequirementCount;
-    d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
-    return sparseMemoryRequirements;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
-  {
-    d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d ) const
-  {
-    std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements;
-    uint32_t sparseMemoryRequirementCount;
-    d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
-    return sparseMemoryRequirements;
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements( vectorAllocator );
-    uint32_t sparseMemoryRequirementCount;
-    d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
-    return sparseMemoryRequirements;
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Sampler,Dispatch>( result, sampler, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerUnique", deleter );
   }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
@@ -44786,6 +48015,758 @@ public:
 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSemaphore*>( pSemaphore ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<Semaphore>::type Device::createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Semaphore semaphore;
+    Result result = static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) );
+    return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING"::Device::createSemaphore" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Semaphore,Dispatch>>::type Device::createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Semaphore semaphore;
+    Result result = static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<Semaphore,Dispatch>( result, semaphore, VULKAN_HPP_NAMESPACE_STRING"::Device::createSemaphoreUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkShaderModule*>( pShaderModule ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<ShaderModule>::type Device::createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    ShaderModule shaderModule;
+    Result result = static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) );
+    return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING"::Device::createShaderModule" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ShaderModule,Dispatch>>::type Device::createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    ShaderModule shaderModule;
+    Result result = static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<ShaderModule,Dispatch>( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING"::Device::createShaderModuleUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, swapchainCount, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchains ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size() );
+    Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( swapchains.data() ) ) );
+    return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainsKHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size(), vectorAllocator );
+    Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( swapchains.data() ) ) );
+    return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainsKHR" );
+  }
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<SwapchainKHR>::type Device::createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    SwapchainKHR swapchain;
+    Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
+    return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainKHR" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle<SwapchainKHR, Dispatch> ), "SwapchainKHR is greater than UniqueHandle<SwapchainKHR, Dispatch>!" );
+    std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> swapchainKHRs;
+    swapchainKHRs.reserve( createInfos.size() );
+    SwapchainKHR* buffer = reinterpret_cast<SwapchainKHR*>( reinterpret_cast<char*>( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueHandle<SwapchainKHR, Dispatch> ) - sizeof( SwapchainKHR ) ) );
+    Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( buffer ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    for ( size_t i=0 ; i<createInfos.size() ; i++ )
+    {
+      swapchainKHRs.push_back( UniqueHandle<SwapchainKHR, Dispatch>( buffer[i], deleter ) );
+    }
+
+    return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle<SwapchainKHR, Dispatch> ), "SwapchainKHR is greater than UniqueHandle<SwapchainKHR, Dispatch>!" );
+    std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> swapchainKHRs( vectorAllocator );
+    swapchainKHRs.reserve( createInfos.size() );
+    SwapchainKHR* buffer = reinterpret_cast<SwapchainKHR*>( reinterpret_cast<char*>( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueHandle<SwapchainKHR, Dispatch> ) - sizeof( SwapchainKHR ) ) );
+    Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( buffer ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    for ( size_t i=0 ; i<createInfos.size() ; i++ )
+    {
+      swapchainKHRs.push_back( UniqueHandle<SwapchainKHR, Dispatch>( buffer[i], deleter ) );
+    }
+
+    return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
+  }
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type Device::createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    SwapchainKHR swapchain;
+    Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<SwapchainKHR,Dispatch>( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainKHRUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchain ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<SwapchainKHR>::type Device::createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    SwapchainKHR swapchain;
+    Result result = static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
+    return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSwapchainKHR" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    SwapchainKHR swapchain;
+    Result result = static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<SwapchainKHR,Dispatch>( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSwapchainKHRUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkValidationCacheEXT*>( pValidationCache ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<ValidationCacheEXT>::type Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    ValidationCacheEXT validationCache;
+    Result result = static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) );
+    return createResultValue( result, validationCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createValidationCacheEXT" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ValidationCacheEXT,Dispatch>>::type Device::createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    ValidationCacheEXT validationCache;
+    Result result = static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) );
+
+    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<ValidationCacheEXT,Dispatch>( result, validationCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createValidationCacheEXTUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( pNameInfo ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( &nameInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::debugMarkerSetObjectNameEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( pTagInfo ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( &tagInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::debugMarkerSetObjectTagEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyEvent( Event event, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Event event, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyImage( Image image, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Image image, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template<typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
@@ -44826,44 +48807,81 @@ public:
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
-    d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2*>( pQueueInfo ), reinterpret_cast<VkQueue*>( pQueue ) );
+    d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Queue Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Queue queue;
-    d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2*>( &queueInfo ), reinterpret_cast<VkQueue*>( &queue ) );
-    return queue;
+    d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkValidationCacheEXT*>( pValidationCache ) ) );
+    d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ValidationCacheEXT>::type Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    ValidationCacheEXT validationCache;
-    Result result = static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) );
-    return createResultValue( result, validationCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createValidationCacheEXT" );
+    d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ValidationCacheEXT,Dispatch>>::type Device::createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    ValidationCacheEXT validationCache;
-    Result result = static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) );
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<ValidationCacheEXT,Dispatch>( result, validationCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createValidationCacheEXTUnique", deleter );
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
@@ -44892,69 +48910,272 @@ public:
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::waitIdle(Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), pDataSize, pData ) );
+    return static_cast<Result>( d.vkDeviceWaitIdle( m_device ) );
   }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d ) const
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::waitIdle(Dispatch const &d ) const
   {
-    std::vector<uint8_t,Allocator> data;
-    size_t dataSize;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
-      if ( ( result == Result::eSuccess ) && dataSize )
-      {
-        data.resize( dataSize );
-        result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( dataSize <= data.size() );
-      data.resize( dataSize );
-    }
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getValidationCacheDataEXT" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<uint8_t,Allocator> data( vectorAllocator );
-    size_t dataSize;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
-      if ( ( result == Result::eSuccess ) && dataSize )
-      {
-        data.resize( dataSize );
-        result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( dataSize <= data.size() );
-      data.resize( dataSize );
-    }
-    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getValidationCacheDataEXT" );
+    Result result = static_cast<Result>( d.vkDeviceWaitIdle( m_device ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitIdle" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCacheCount, reinterpret_cast<const VkValidationCacheEXT*>( pSrcCaches ) ) );
+    return static_cast<Result>( d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( pDisplayPowerInfo ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> srcCaches, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d ) const
   {
-    Result result = static_cast<Result>( d.vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCaches.size() , reinterpret_cast<const VkValidationCacheEXT*>( srcCaches.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergeValidationCachesEXT" );
+    Result result = static_cast<Result>( d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( &displayPowerInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::displayPowerControlEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkFlushMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::flushMappedMemoryRanges" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
+  {
+    d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
+  {
+    d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
+  {
+    d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
+  {
+    d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::freeDescriptorSets" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::free( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::free" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::free( DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), dataSize, pData ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename T, typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getAccelerationStructureHandleNV" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d) const
+  {
+    d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( pInfo ), reinterpret_cast<VkMemoryRequirements2KHR*>( pMemoryRequirements ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d ) const
+  {
+    MemoryRequirements2KHR memoryRequirements;
+    d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    MemoryRequirements2KHR& memoryRequirements = structureChain.template get<MemoryRequirements2KHR>();
+    d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( pProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
+  {
+    AndroidHardwareBufferPropertiesANDROID properties;
+    Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    AndroidHardwareBufferPropertiesANDROID& properties = structureChain.template get<AndroidHardwareBufferPropertiesANDROID>();
+    Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
+    return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements, Dispatch const &d) const
+  {
+    d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE MemoryRequirements Device::getBufferMemoryRequirements( Buffer buffer, Dispatch const &d ) const
+  {
+    MemoryRequirements memoryRequirements;
+    d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+  {
+    d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  {
+    MemoryRequirements2 memoryRequirements;
+    d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
+    d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+  {
+    d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  {
+    MemoryRequirements2 memoryRequirements;
+    d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
+    d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetCalibratedTimestampsEXT( m_device, timestampCount, reinterpret_cast<const VkCalibratedTimestampInfoEXT*>( pTimestampInfos ), pTimestamps, pMaxDeviation ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d ) const
+  {
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( timestampInfos.size() == timestamps.size() );
+#else
+    if ( timestampInfos.size() != timestamps.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkDevice::getCalibratedTimestampsEXT: timestampInfos.size() != timestamps.size()" );
+    }
+#endif  /*VULKAN_HPP_NO_EXCEPTIONS*/
+    uint64_t maxDeviation;
+    Result result = static_cast<Result>( d.vkGetCalibratedTimestampsEXT( m_device, timestampInfos.size() , reinterpret_cast<const VkCalibratedTimestampInfoEXT*>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) );
+    return createResultValue( result, maxDeviation, VULKAN_HPP_NAMESPACE_STRING"::Device::getCalibratedTimestampsEXT" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -44971,7 +49192,7 @@ public:
     d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
     return support;
   }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
@@ -44994,7 +49215,7 @@ public:
     d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
     return support;
   }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
   VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
   {
     StructureChain<X, Y, Z...> structureChain;
@@ -45004,13 +49225,675 @@ public:
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
+  {
+    d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
+  {
+    PeerMemoryFeatureFlags peerMemoryFeatures;
+    d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
+    return peerMemoryFeatures;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
+  {
+    d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
+  {
+    PeerMemoryFeatureFlags peerMemoryFeatures;
+    d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
+    return peerMemoryFeatures;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>( pDeviceGroupPresentCapabilities ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentCapabilitiesKHR>::type Device::getGroupPresentCapabilitiesKHR(Dispatch const &d ) const
+  {
+    DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
+    Result result = static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>( &deviceGroupPresentCapabilities ) ) );
+    return createResultValue( result, deviceGroupPresentCapabilities, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupPresentCapabilitiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( pModes ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentModeFlagsKHR>::type Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d ) const
+  {
+    DeviceGroupPresentModeFlagsKHR modes;
+    Result result = static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( &modes ) ) );
+    return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupSurfacePresentModesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d) const
+  {
+    d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize*>( pCommittedMemoryInBytes ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE DeviceSize Device::getMemoryCommitment( DeviceMemory memory, Dispatch const &d ) const
+  {
+    DeviceSize committedMemoryInBytes;
+    d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize*>( &committedMemoryInBytes ) );
+    return committedMemoryInBytes;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char* pName, Dispatch const &d) const
+  {
+    return d.vkGetDeviceProcAddr( m_device, pName );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name, Dispatch const &d ) const
+  {
+    return d.vkGetDeviceProcAddr( m_device, name.c_str() );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d) const
+  {
+    d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( pQueue ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d ) const
+  {
+    Queue queue;
+    d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( &queue ) );
+    return queue;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d) const
+  {
+    d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2*>( pQueueInfo ), reinterpret_cast<VkQueue*>( pQueue ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Queue Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d ) const
+  {
+    Queue queue;
+    d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2*>( &queueInfo ), reinterpret_cast<VkQueue*>( &queue ) );
+    return queue;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getEventStatus", { Result::eEventSet, Result::eEventReset } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<int>::type Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const &d ) const
+  {
+    int fd;
+    Result result = static_cast<Result>( d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR*>( &getFdInfo ), &fd ) );
+    return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceFdKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceStatus", { Result::eSuccess, Result::eNotReady } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const
+  {
+    HANDLE handle;
+    Result result = static_cast<Result>( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) );
+    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceWin32HandleKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( Image image, ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( pProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type Device::getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const &d ) const
+  {
+    ImageDrmFormatModifierPropertiesEXT properties;
+    Result result = static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( &properties ) ) );
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getImageDrmFormatModifierPropertiesEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d) const
+  {
+    d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE MemoryRequirements Device::getImageMemoryRequirements( Image image, Dispatch const &d ) const
+  {
+    MemoryRequirements memoryRequirements;
+    d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+  {
+    d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  {
+    MemoryRequirements2 memoryRequirements;
+    d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
+    d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+  {
+    d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  {
+    MemoryRequirements2 memoryRequirements;
+    d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
+    return memoryRequirements;
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
+    d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d) const
+  {
+    d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( pSparseMemoryRequirements ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( Image image, Dispatch const &d ) const
+  {
+    std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements;
+    uint32_t sparseMemoryRequirementCount;
+    d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
+    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+    d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( sparseMemoryRequirements.data() ) );
+    return sparseMemoryRequirements;
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements( vectorAllocator );
+    uint32_t sparseMemoryRequirementCount;
+    d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
+    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+    d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( sparseMemoryRequirements.data() ) );
+    return sparseMemoryRequirements;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
+  {
+    d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  {
+    std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements;
+    uint32_t sparseMemoryRequirementCount;
+    d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
+    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+    d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
+    return sparseMemoryRequirements;
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements( vectorAllocator );
+    uint32_t sparseMemoryRequirementCount;
+    d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
+    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+    d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
+    return sparseMemoryRequirements;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
+  {
+    d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+  {
+    std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements;
+    uint32_t sparseMemoryRequirementCount;
+    d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
+    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+    d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
+    return sparseMemoryRequirements;
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements( vectorAllocator );
+    uint32_t sparseMemoryRequirementCount;
+    d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
+    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
+    d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
+    return sparseMemoryRequirements;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d) const
+  {
+    d.vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( pSubresource ), reinterpret_cast<VkSubresourceLayout*>( pLayout ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE SubresourceLayout Device::getImageSubresourceLayout( Image image, const ImageSubresource & subresource, Dispatch const &d ) const
+  {
+    SubresourceLayout layout;
+    d.vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( &subresource ), reinterpret_cast<VkSubresourceLayout*>( &layout ) );
+    return layout;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>( pInfo ), pBuffer ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<struct AHardwareBuffer*>::type Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const &d ) const
+  {
+    struct AHardwareBuffer* buffer;
+    Result result = static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>( &info ), &buffer ) );
+    return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryAndroidHardwareBufferANDROID" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<int>::type Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const &d ) const
+  {
+    int fd;
+    Result result = static_cast<Result>( d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR*>( &getFdInfo ), &fd ) );
+    return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryFdKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( pMemoryFdProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<MemoryFdPropertiesKHR>::type Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d ) const
+  {
+    MemoryFdPropertiesKHR memoryFdProperties;
+    Result result = static_cast<Result>( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( &memoryFdProperties ) ) );
+    return createResultValue( result, memoryFdProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryFdPropertiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( pMemoryHostPointerProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<MemoryHostPointerPropertiesEXT>::type Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d ) const
+  {
+    MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
+    Result result = static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( &memoryHostPointerProperties ) ) );
+    return createResultValue( result, memoryHostPointerProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryHostPointerPropertiesEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const
+  {
+    HANDLE handle;
+    Result result = static_cast<Result>( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) );
+    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandleKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), pHandle ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d ) const
+  {
+    HANDLE handle;
+    Result result = static_cast<Result>( d.vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle ) );
+    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandleNV" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( pMemoryWin32HandleProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<MemoryWin32HandlePropertiesKHR>::type Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d ) const
+  {
+    MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
+    Result result = static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( &memoryWin32HandleProperties ) ) );
+    return createResultValue( result, memoryWin32HandleProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandlePropertiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), pPresentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( pPresentationTimings ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const &d ) const
+  {
+    std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings;
+    uint32_t presentationTimingCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && presentationTimingCount )
+      {
+        presentationTimings.resize( presentationTimingCount );
+        result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( presentationTimings.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
+      presentationTimings.resize( presentationTimingCount );
+    }
+    return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING"::Device::getPastPresentationTimingGOOGLE" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings( vectorAllocator );
+    uint32_t presentationTimingCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && presentationTimingCount )
+      {
+        presentationTimings.resize( presentationTimingCount );
+        result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( presentationTimings.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
+      presentationTimings.resize( presentationTimingCount );
+    }
+    return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING"::Device::getPastPresentationTimingGOOGLE" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), pDataSize, pData ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d ) const
+  {
+    std::vector<uint8_t,Allocator> data;
+    size_t dataSize;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
+      if ( ( result == Result::eSuccess ) && dataSize )
+      {
+        data.resize( dataSize );
+        result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( dataSize <= data.size() );
+      data.resize( dataSize );
+    }
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineCacheData" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<uint8_t,Allocator> data( vectorAllocator );
+    size_t dataSize;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
+      if ( ( result == Result::eSuccess ) && dataSize )
+      {
+        data.resize( dataSize );
+        result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( dataSize <= data.size() );
+      data.resize( dataSize );
+    }
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineCacheData" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, dataSize, pData, static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename T, typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ), static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename T, typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRayTracingShaderGroupHandlesNV" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( pDisplayTimingProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<RefreshCycleDurationGOOGLE>::type Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const &d ) const
+  {
+    RefreshCycleDurationGOOGLE displayTimingProperties;
+    Result result = static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( &displayTimingProperties ) ) );
+    return createResultValue( result, displayTimingProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getRefreshCycleDurationGOOGLE" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d) const
+  {
+    d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( pGranularity ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Extent2D Device::getRenderAreaGranularity( RenderPass renderPass, Dispatch const &d ) const
+  {
+    Extent2D granularity;
+    d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( &granularity ) );
+    return granularity;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<int>::type Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const &d ) const
+  {
+    int fd;
+    Result result = static_cast<Result>( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( &getFdInfo ), &fd ) );
+    return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getSemaphoreFdKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const
+  {
+    HANDLE handle;
+    Result result = static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) );
+    return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getSemaphoreWin32HandleKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
   template<typename Dispatch>
   VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d) const
   {
     return static_cast<Result>( d.vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), pInfoSize, pInfo ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
+  template<typename Allocator, typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d ) const
   {
     std::vector<uint8_t,Allocator> info;
@@ -45032,7 +49915,7 @@ public:
     }
     return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING"::Device::getShaderInfoAMD" );
   }
-  template <typename Allocator, typename Dispatch> 
+  template<typename Allocator, typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<uint8_t,Allocator> info( vectorAllocator );
@@ -45057,25 +49940,364 @@ public:
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkGetCalibratedTimestampsEXT( m_device, timestampCount, reinterpret_cast<const VkCalibratedTimestampInfoEXT*>( pTimestampInfos ), pTimestamps, pMaxDeviation ) );
+    return static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), pCounterValue ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const &d ) const
+  {
+    uint64_t counterValue;
+    Result result = static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ) );
+    return createResultValue( result, counterValue, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainCounterEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), pSwapchainImageCount, reinterpret_cast<VkImage*>( pSwapchainImages ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d ) const
+  {
+    std::vector<Image,Allocator> swapchainImages;
+    uint32_t swapchainImageCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && swapchainImageCount )
+      {
+        swapchainImages.resize( swapchainImageCount );
+        result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage*>( swapchainImages.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
+      swapchainImages.resize( swapchainImageCount );
+    }
+    return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainImagesKHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<Image,Allocator> swapchainImages( vectorAllocator );
+    uint32_t swapchainImageCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && swapchainImageCount )
+      {
+        swapchainImages.resize( swapchainImageCount );
+        result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage*>( swapchainImages.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
+      swapchainImages.resize( swapchainImageCount );
+    }
+    return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainImagesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), pDataSize, pData ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d ) const
+  {
+    std::vector<uint8_t,Allocator> data;
+    size_t dataSize;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
+      if ( ( result == Result::eSuccess ) && dataSize )
+      {
+        data.resize( dataSize );
+        result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( dataSize <= data.size() );
+      data.resize( dataSize );
+    }
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getValidationCacheDataEXT" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<uint8_t,Allocator> data( vectorAllocator );
+    size_t dataSize;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
+      if ( ( result == Result::eSuccess ) && dataSize )
+      {
+        data.resize( dataSize );
+        result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( dataSize <= data.size() );
+      data.resize( dataSize );
+    }
+    return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getValidationCacheDataEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR*>( pImportFenceFdInfo ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR*>( &importFenceFdInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importFenceFdKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( pImportFenceWin32HandleInfo ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( &importFenceWin32HandleInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importFenceWin32HandleKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( pImportSemaphoreFdInfo ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( &importSemaphoreFdInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importSemaphoreFdKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( pImportSemaphoreWin32HandleInfo ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( &importSemaphoreWin32HandleInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importSemaphoreWin32HandleKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkInvalidateMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::invalidateMappedMemoryRanges" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( offset ), static_cast<VkDeviceSize>( size ), static_cast<VkMemoryMapFlags>( flags ), ppData ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void*>::type Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, Dispatch const &d ) const
+  {
+    void* pData;
+    Result result = static_cast<Result>( d.vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( offset ), static_cast<VkDeviceSize>( size ), static_cast<VkMemoryMapFlags>( flags ), &pData ) );
+    return createResultValue( result, pData, VULKAN_HPP_NAMESPACE_STRING"::Device::mapMemory" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCacheCount, reinterpret_cast<const VkPipelineCache*>( pSrcCaches ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCaches.size() , reinterpret_cast<const VkPipelineCache*>( srcCaches.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergePipelineCaches" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCacheCount, reinterpret_cast<const VkValidationCacheEXT*>( pSrcCaches ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> srcCaches, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCaches.size() , reinterpret_cast<const VkValidationCacheEXT*>( srcCaches.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergeValidationCachesEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( pDeviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Fence fence;
+    Result result = static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( &deviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
+    return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerEventEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( pDisplayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    Fence fence;
+    Result result = static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( &displayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
+    return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerDisplayEventEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkRegisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectTableEntryNVX* const*>( ppObjectTableEntries ), pObjectIndices ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d ) const
   {
 #ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( timestampInfos.size() == timestamps.size() );
+    VULKAN_HPP_ASSERT( pObjectTableEntries.size() == objectIndices.size() );
 #else
-    if ( timestampInfos.size() != timestamps.size() )
+    if ( pObjectTableEntries.size() != objectIndices.size() )
     {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT: timestampInfos.size() != timestamps.size()" );
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkDevice::registerObjectsNVX: pObjectTableEntries.size() != objectIndices.size()" );
     }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    uint64_t maxDeviation;
-    Result result = static_cast<Result>( d.vkGetCalibratedTimestampsEXT( m_device, timestampInfos.size() , reinterpret_cast<const VkCalibratedTimestampInfoEXT*>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) );
-    return createResultValue( result, maxDeviation, VULKAN_HPP_NAMESPACE_STRING"::Device::getCalibratedTimestampsEXT" );
+#endif  /*VULKAN_HPP_NO_EXCEPTIONS*/
+    Result result = static_cast<Result>( d.vkRegisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), pObjectTableEntries.size() , reinterpret_cast<const VkObjectTableEntryNVX* const*>( pObjectTableEntries.data() ), objectIndices.data() ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::registerObjectsNVX" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetCommandPool" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetDescriptorPool" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::resetEvent( Event event, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetEvent( Event event, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetEvent" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkResetFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetFences( ArrayProxy<const Fence> fences, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkResetFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetFences" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -45107,3027 +50329,158 @@ public:
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( pMemoryHostPointerProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<MemoryHostPointerPropertiesEXT>::type Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d ) const
-  {
-    MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
-    Result result = static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( &memoryHostPointerProperties ) ) );
-    return createResultValue( result, memoryHostPointerProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryHostPointerPropertiesEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createRenderPass2KHR( const RenderPassCreateInfo2KHR* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<RenderPass>::type Device::createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    RenderPass renderPass;
-    Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
-    return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type Device::createRenderPass2KHRUnique( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    RenderPass renderPass;
-    Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<RenderPass,Dispatch>( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
-  {
-    AndroidHardwareBufferPropertiesANDROID properties;
-    Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
-  }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
-  {
-    StructureChain<X, Y, Z...> structureChain;
-    AndroidHardwareBufferPropertiesANDROID& properties = structureChain.template get<AndroidHardwareBufferPropertiesANDROID>();
-    Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
-    return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>( pInfo ), pBuffer ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<struct AHardwareBuffer*>::type Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const &d ) const
-  {
-    struct AHardwareBuffer* buffer;
-    Result result = static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>( &info ), &buffer ) );
-    return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryAndroidHardwareBufferANDROID" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::setEvent( Event event, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
+    return static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::setEvent( Event event, Dispatch const &d ) const
   {
-    Result result = static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::compileDeferredNV" );
+    Result result = static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::setEvent" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkAccelerationStructureNV*>( pAccelerationStructure ) ) );
+    d.vkSetHdrMetadataEXT( m_device, swapchainCount, reinterpret_cast<const VkSwapchainKHR*>( pSwapchains ), reinterpret_cast<const VkHdrMetadataEXT*>( pMetadata ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<AccelerationStructureNV>::type Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> swapchains, ArrayProxy<const HdrMetadataEXT> metadata, Dispatch const &d ) const
   {
-    AccelerationStructureNV accelerationStructure;
-    Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNV*>( &accelerationStructure ) ) );
-    return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNV" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<AccelerationStructureNV,Dispatch>>::type Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    AccelerationStructureNV accelerationStructure;
-    Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNV*>( &accelerationStructure ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<AccelerationStructureNV,Dispatch>( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNVUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d) const
-  {
-    d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( pInfo ), reinterpret_cast<VkMemoryRequirements2KHR*>( pMemoryRequirements ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d ) const
-  {
-    MemoryRequirements2KHR memoryRequirements;
-    d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>( pBindInfos ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindAccelerationStructureMemoryNV( ArrayProxy<const BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfos.size() , reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>( bindInfos.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindAccelerationStructureMemoryNV" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRayTracingShaderGroupHandlesNV" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), dataSize, pData ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T, typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d ) const
-  {
-    Result result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getAccelerationStructureHandleNV" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
-    Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
-    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
-    Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
-    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" );
-  }
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Pipeline pipeline;
-    Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
-    return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelineNV" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
-    std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
-    pipelines.reserve( createInfos.size() );
-    Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
-    Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    for ( size_t i=0 ; i<createInfos.size() ; i++ )
-    {
-      pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
-    }
-
-    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
-    std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
-    pipelines.reserve( createInfos.size() );
-    Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniqueHandle<Pipeline, Dispatch> ) - sizeof( Pipeline ) ) );
-    Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    for ( size_t i=0 ; i<createInfos.size() ; i++ )
-    {
-      pipelines.push_back( UniqueHandle<Pipeline, Dispatch>( buffer[i], deleter ) );
-    }
-
-    return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" );
-  }
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Pipeline pipeline;
-    Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
-
-    ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<Pipeline,Dispatch>( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelineNVUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( Image image, ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type Device::getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const &d ) const
-  {
-    ImageDrmFormatModifierPropertiesEXT properties;
-    Result result = static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( &properties ) ) );
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getImageDrmFormatModifierPropertiesEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-
-  template <typename Dispatch> class UniqueHandleTraits<Device,Dispatch> {public: using deleter = ObjectDestroy<NoParent,Dispatch>; };
-  using UniqueDevice = UniqueHandle<Device,DispatchLoaderStatic>;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  class PhysicalDevice
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR PhysicalDevice()
-      : m_physicalDevice(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t )
-      : m_physicalDevice(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice )
-      : m_physicalDevice( physicalDevice )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    PhysicalDevice & operator=(VkPhysicalDevice physicalDevice)
-    {
-      m_physicalDevice = physicalDevice;
-      return *this; 
-    }
-#endif
-
-    PhysicalDevice & operator=( std::nullptr_t )
-    {
-      m_physicalDevice = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( PhysicalDevice const & rhs ) const
-    {
-      return m_physicalDevice == rhs.m_physicalDevice;
-    }
-
-    bool operator!=(PhysicalDevice const & rhs ) const
-    {
-      return m_physicalDevice != rhs.m_physicalDevice;
-    }
-
-    bool operator<(PhysicalDevice const & rhs ) const
-    {
-      return m_physicalDevice < rhs.m_physicalDevice;
-    }
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getProperties( PhysicalDeviceProperties* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    PhysicalDeviceProperties getProperties(Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<X, Y, Z...> getProperties(Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties(Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties(Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    PhysicalDeviceMemoryProperties getMemoryProperties(Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getFeatures( PhysicalDeviceFeatures* pFeatures, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    PhysicalDeviceFeatures getFeatures(Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getFormatProperties( Format format, FormatProperties* pFormatProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    FormatProperties getFormatProperties( Format format, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<ImageFormatProperties>::type getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Device>::type createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<Device,Dispatch>>::type createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties(Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName = nullptr, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<DisplayPropertiesKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR(Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<DisplayPropertiesKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<DisplayPlanePropertiesKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR(Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<DisplayPlanePropertiesKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<DisplayModeKHR>::type createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Bool32>::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SurfaceCapabilitiesKHR>::type getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d = Dispatch() ) const;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<ExternalImageFormatPropertiesNV>::type getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    DeviceGeneratedCommandsLimitsNVX getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getFeatures2( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<X, Y, Z...> getFeatures2(Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getFeatures2KHR( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<X, Y, Z...> getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getProperties2( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    PhysicalDeviceProperties2 getProperties2(Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<X, Y, Z...> getProperties2(Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getProperties2KHR( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<X, Y, Z...> getProperties2KHR(Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getFormatProperties2( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    FormatProperties2 getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<X, Y, Z...> getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getFormatProperties2KHR( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    FormatProperties2 getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    StructureChain<X, Y, Z...> getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<ImageFormatProperties2>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<ImageFormatProperties2>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2(Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2KHR(Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic> 
-    std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ExternalBufferProperties getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ExternalBufferProperties getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ExternalSemaphoreProperties getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ExternalFenceProperties getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ExternalFenceProperties getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() );
 #else
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<void>::type releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<Display>::type acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<DisplayKHR>::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SurfaceCapabilities2EXT>::type getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getPresentRectanglesKHR( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<Rect2D>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<Rect2D>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    MultisamplePropertiesEXT getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<StructureChain<X, Y, Z...>>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SurfaceFormat2KHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<SurfaceFormat2KHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getDisplayProperties2KHR( uint32_t* pPropertyCount, DisplayProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<DisplayProperties2KHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type getDisplayProperties2KHR(Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<DisplayProperties2KHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type getDisplayProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, DisplayPlaneProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<DisplayPlaneProperties2KHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type getDisplayPlaneProperties2KHR(Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<DisplayPlaneProperties2KHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type getDisplayPlaneProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getDisplayModeProperties2KHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModeProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR* pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<DisplayPlaneCapabilities2KHR>::type getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<TimeDomainEXT>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type getCalibrateableTimeDomainsEXT(Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<TimeDomainEXT>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type getCalibrateableTimeDomainsEXT(Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const
+    if ( swapchains.size() != metadata.size() )
     {
-      return m_physicalDevice;
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkDevice::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
     }
-
-    explicit operator bool() const
-    {
-      return m_physicalDevice != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_physicalDevice == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkPhysicalDevice m_physicalDevice;
-  };
-
-  static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" );
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getProperties( PhysicalDeviceProperties* pProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( pProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceProperties PhysicalDevice::getProperties(Dispatch const &d ) const
-  {
-    PhysicalDeviceProperties properties;
-    d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
-    return properties;
-  }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties(Dispatch const &d ) const
-  {
-    StructureChain<X, Y, Z...> structureChain;
-    PhysicalDeviceProperties& properties = structureChain.template get<PhysicalDeviceProperties>();
-    d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( pQueueFamilyProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties,Allocator> PhysicalDevice::getQueueFamilyProperties(Dispatch const &d ) const
-  {
-    std::vector<QueueFamilyProperties,Allocator> queueFamilyProperties;
-    uint32_t queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( queueFamilyProperties.data() ) );
-    return queueFamilyProperties;
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties,Allocator> PhysicalDevice::getQueueFamilyProperties(Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<QueueFamilyProperties,Allocator> queueFamilyProperties( vectorAllocator );
-    uint32_t queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( queueFamilyProperties.data() ) );
-    return queueFamilyProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( pMemoryProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties(Dispatch const &d ) const
-  {
-    PhysicalDeviceMemoryProperties memoryProperties;
-    d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( &memoryProperties ) );
-    return memoryProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( PhysicalDeviceFeatures* pFeatures, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( pFeatures ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceFeatures PhysicalDevice::getFeatures(Dispatch const &d ) const
-  {
-    PhysicalDeviceFeatures features;
-    d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( &features ) );
-    return features;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties( Format format, FormatProperties* pFormatProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( pFormatProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE FormatProperties PhysicalDevice::getFormatProperties( Format format, Dispatch const &d ) const
-  {
-    FormatProperties formatProperties;
-    d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( &formatProperties ) );
-    return formatProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), reinterpret_cast<VkImageFormatProperties*>( pImageFormatProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties>::type PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const &d ) const
-  {
-    ImageFormatProperties imageFormatProperties;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), reinterpret_cast<VkImageFormatProperties*>( &imageFormatProperties ) ) );
-    return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDevice*>( pDevice ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Device>::type PhysicalDevice::createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Device device;
-    Result result = static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) );
-    return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDevice" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Device,Dispatch>>::type PhysicalDevice::createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    Device device;
-    Result result = static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) );
-
-    ObjectDestroy<NoParent,Dispatch> deleter( allocator, d );
-    return createResultValue<Device,Dispatch>( result, device, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDeviceUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type PhysicalDevice::enumerateDeviceLayerProperties(Dispatch const &d ) const
-  {
-    std::vector<LayerProperties,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceLayerProperties" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type PhysicalDevice::enumerateDeviceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<LayerProperties,Allocator> properties( vectorAllocator );
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceLayerProperties" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName, Dispatch const &d ) const
-  {
-    std::vector<ExtensionProperties,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceExtensionProperties" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<ExtensionProperties,Allocator> properties( vectorAllocator );
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceExtensionProperties" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( pProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d ) const
-  {
-    std::vector<SparseImageFormatProperties,Allocator> properties;
-    uint32_t propertyCount;
-    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, nullptr );
-    properties.resize( propertyCount );
-    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( properties.data() ) );
-    return properties;
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<SparseImageFormatProperties,Allocator> properties( vectorAllocator );
-    uint32_t propertyCount;
-    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, nullptr );
-    properties.resize( propertyCount );
-    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( properties.data() ) );
-    return properties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPropertiesKHR(Dispatch const &d ) const
-  {
-    std::vector<DisplayPropertiesKHR,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPropertiesKHR" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<DisplayPropertiesKHR,Allocator> properties( vectorAllocator );
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPlanePropertiesKHR(Dispatch const &d ) const
-  {
-    std::vector<DisplayPlanePropertiesKHR,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlanePropertiesKHR" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPlanePropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<DisplayPlanePropertiesKHR,Allocator> properties( vectorAllocator );
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlanePropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR*>( pDisplays ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const &d ) const
-  {
-    std::vector<DisplayKHR,Allocator> displays;
-    uint32_t displayCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && displayCount )
-      {
-        displays.resize( displayCount );
-        result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR*>( displays.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( displayCount <= displays.size() );
-      displays.resize( displayCount );
-    }
-    return createResultValue( result, displays, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<DisplayKHR,Allocator> displays( vectorAllocator );
-    uint32_t displayCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && displayCount )
-      {
-        displays.resize( displayCount );
-        result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR*>( displays.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( displayCount <= displays.size() );
-      displays.resize( displayCount );
-    }
-    return createResultValue( result, displays, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const &d ) const
-  {
-    std::vector<DisplayModePropertiesKHR,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModePropertiesKHR" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<DisplayModePropertiesKHR,Allocator> properties( vectorAllocator );
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModePropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDisplayModeKHR*>( pMode ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DisplayModeKHR>::type PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    DisplayModeKHR mode;
-    Result result = static_cast<Result>( d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDisplayModeKHR*>( &mode ) ) );
-    return createResultValue( result, mode, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDisplayModeKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( pCapabilities ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DisplayPlaneCapabilitiesKHR>::type PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d ) const
-  {
-    DisplayPlaneCapabilitiesKHR capabilities;
-    Result result = static_cast<Result>( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( &capabilities ) ) );
-    return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), pSupported ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Bool32>::type PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d ) const
-  {
-    Bool32 supported;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), &supported ) );
-    return createResultValue( result, supported, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceSupportKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( pSurfaceCapabilities ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilitiesKHR>::type PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const &d ) const
-  {
-    SurfaceCapabilitiesKHR surfaceCapabilities;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( &surfaceCapabilities ) ) );
-    return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilitiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( pSurfaceFormats ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const &d ) const
-  {
-    std::vector<SurfaceFormatKHR,Allocator> surfaceFormats;
-    uint32_t surfaceFormatCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
-      {
-        surfaceFormats.resize( surfaceFormatCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
-      surfaceFormats.resize( surfaceFormatCount );
-    }
-    return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormatsKHR" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<SurfaceFormatKHR,Allocator> surfaceFormats( vectorAllocator );
-    uint32_t surfaceFormatCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
-      {
-        surfaceFormats.resize( surfaceFormatCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
-      surfaceFormats.resize( surfaceFormatCount );
-    }
-    return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormatsKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>( pPresentModes ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d ) const
-  {
-    std::vector<PresentModeKHR,Allocator> presentModes;
-    uint32_t presentModeCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && presentModeCount )
-      {
-        presentModes.resize( presentModeCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
-      presentModes.resize( presentModeCount );
-    }
-    return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModesKHR" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<PresentModeKHR,Allocator> presentModes( vectorAllocator );
-    uint32_t presentModeCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && presentModeCount )
-      {
-        presentModes.resize( presentModeCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
-      presentModes.resize( presentModeCount );
-    }
-    return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display, Dispatch const &d) const
-  {
-    return d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const &d ) const
-  {
-    return d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d) const
-  {
-    return d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex );
-  }
-#else
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d ) const
-  {
-    return d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID, Dispatch const &d) const
-  {
-    return d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const &d ) const
-  {
-    return d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id, Dispatch const &d) const
-  {
-    return d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const &d ) const
-  {
-    return d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( pExternalImageFormatProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ExternalImageFormatPropertiesNV>::type PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d ) const
-  {
-    ExternalImageFormatPropertiesNV externalImageFormatProperties;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( &externalImageFormatProperties ) ) );
-    return createResultValue( result, externalImageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getExternalImageFormatPropertiesNV" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( pFeatures ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( pLimits ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE DeviceGeneratedCommandsLimitsNVX PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d ) const
-  {
-    DeviceGeneratedCommandsLimitsNVX limits;
-    d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( &features ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( &limits ) );
-    return limits;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2(Dispatch const &d ) const
-  {
-    PhysicalDeviceFeatures2 features;
-    d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
-    return features;
-  }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2(Dispatch const &d ) const
-  {
-    StructureChain<X, Y, Z...> structureChain;
-    PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
-    d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
-  {
-    PhysicalDeviceFeatures2 features;
-    d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
-    return features;
-  }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
-  {
-    StructureChain<X, Y, Z...> structureChain;
-    PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
-    d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( PhysicalDeviceProperties2* pProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2(Dispatch const &d ) const
-  {
-    PhysicalDeviceProperties2 properties;
-    d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
-    return properties;
-  }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2(Dispatch const &d ) const
-  {
-    StructureChain<X, Y, Z...> structureChain;
-    PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
-    d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( PhysicalDeviceProperties2* pProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
-  {
-    PhysicalDeviceProperties2 properties;
-    d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
-    return properties;
-  }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
-  {
-    StructureChain<X, Y, Z...> structureChain;
-    PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
-    d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2( Format format, FormatProperties2* pFormatProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2( Format format, Dispatch const &d ) const
-  {
-    FormatProperties2 formatProperties;
-    d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
-    return formatProperties;
-  }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2( Format format, Dispatch const &d ) const
-  {
-    StructureChain<X, Y, Z...> structureChain;
-    FormatProperties2& formatProperties = structureChain.template get<FormatProperties2>();
-    d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( Format format, FormatProperties2* pFormatProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2KHR( Format format, Dispatch const &d ) const
-  {
-    FormatProperties2 formatProperties;
-    d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
-    return formatProperties;
-  }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2KHR( Format format, Dispatch const &d ) const
-  {
-    StructureChain<X, Y, Z...> structureChain;
-    FormatProperties2& formatProperties = structureChain.template get<FormatProperties2>();
-    d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
-  {
-    ImageFormatProperties2 imageFormatProperties;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
-    return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
-  }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
-  {
-    StructureChain<X, Y, Z...> structureChain;
-    ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
-    return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
-  {
-    ImageFormatProperties2 imageFormatProperties;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
-    return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
-  }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
-  {
-    StructureChain<X, Y, Z...> structureChain;
-    ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
-    return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2(Dispatch const &d ) const
-  {
-    std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties;
-    uint32_t queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
-    return queueFamilyProperties;
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties( vectorAllocator );
-    uint32_t queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
-    return queueFamilyProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2KHR(Dispatch const &d ) const
-  {
-    std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties;
-    uint32_t queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
-    return queueFamilyProperties;
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties( vectorAllocator );
-    uint32_t queueFamilyPropertyCount;
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
-    return queueFamilyProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2(Dispatch const &d ) const
-  {
-    PhysicalDeviceMemoryProperties2 memoryProperties;
-    d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
-    return memoryProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const
-  {
-    PhysicalDeviceMemoryProperties2 memoryProperties;
-    d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
-    return memoryProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d ) const
-  {
-    std::vector<SparseImageFormatProperties2,Allocator> properties;
-    uint32_t propertyCount;
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
-    properties.resize( propertyCount );
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
-    return properties;
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<SparseImageFormatProperties2,Allocator> properties( vectorAllocator );
-    uint32_t propertyCount;
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
-    properties.resize( propertyCount );
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
-    return properties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d ) const
-  {
-    std::vector<SparseImageFormatProperties2,Allocator> properties;
-    uint32_t propertyCount;
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
-    properties.resize( propertyCount );
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
-    return properties;
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<SparseImageFormatProperties2,Allocator> properties( vectorAllocator );
-    uint32_t propertyCount;
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
-    properties.resize( propertyCount );
-    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
-    return properties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ExternalBufferProperties PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const
-  {
-    ExternalBufferProperties externalBufferProperties;
-    d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
-    return externalBufferProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ExternalBufferProperties PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const
-  {
-    ExternalBufferProperties externalBufferProperties;
-    d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
-    return externalBufferProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const
-  {
-    ExternalSemaphoreProperties externalSemaphoreProperties;
-    d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
-    return externalSemaphoreProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const
-  {
-    ExternalSemaphoreProperties externalSemaphoreProperties;
-    d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
-    return externalSemaphoreProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ExternalFenceProperties PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const
-  {
-    ExternalFenceProperties externalFenceProperties;
-    d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
-    return externalFenceProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
-  {
-    d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ExternalFenceProperties PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const
-  {
-    ExternalFenceProperties externalFenceProperties;
-    d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
-    return externalFenceProperties;
+#endif  /*VULKAN_HPP_NO_EXCEPTIONS*/
+    d.vkSetHdrMetadataEXT( m_device, swapchains.size() , reinterpret_cast<const VkSwapchainKHR*>( swapchains.data() ), reinterpret_cast<const VkHdrMetadataEXT*>( metadata.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
+    d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
   }
 #else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<void>::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d ) const
   {
-    Result result = static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
-    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::releaseDisplayEXT" );
+    d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast<VkDisplayKHR>( display ) ) );
+    d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
   }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+#else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Display>::type PhysicalDevice::acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d ) const
   {
-    Display dpy;
-    Result result = static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) );
-    return createResultValue( result, dpy, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::acquireXlibDisplayEXT" );
+    d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
 
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( pDisplay ) ) );
+    d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
   }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+#else
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DisplayKHR>::type PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d ) const
   {
-    DisplayKHR display;
-    Result result = static_cast<Result>( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( &display ) ) );
-    return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getRandROutputDisplayEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( pSurfaceCapabilities ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2EXT>::type PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const &d ) const
-  {
-    SurfaceCapabilities2EXT surfaceCapabilities;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( &surfaceCapabilities ) ) );
-    return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2EXT" );
+    d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pRectCount, reinterpret_cast<VkRect2D*>( pRects ) ) );
+    return static_cast<Result>( d.vkUnregisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectEntryTypeNVX*>( pObjectEntryTypes ), pObjectIndices ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const &d ) const
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Device::unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d ) const
   {
-    std::vector<Rect2D,Allocator> rects;
-    uint32_t rectCount;
-    Result result;
-    do
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( objectEntryTypes.size() == objectIndices.size() );
+#else
+    if ( objectEntryTypes.size() != objectIndices.size() )
     {
-      result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && rectCount )
-      {
-        rects.resize( rectCount );
-        result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D*>( rects.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( rectCount <= rects.size() );
-      rects.resize( rectCount );
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkDevice::unregisterObjectsNVX: objectEntryTypes.size() != objectIndices.size()" );
     }
-    return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getPresentRectanglesKHR" );
+#endif  /*VULKAN_HPP_NO_EXCEPTIONS*/
+    Result result = static_cast<Result>( d.vkUnregisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectEntryTypes.size() , reinterpret_cast<const VkObjectEntryTypeNVX*>( objectEntryTypes.data() ), objectIndices.data() ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::unregisterObjectsNVX" );
   }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
   {
-    std::vector<Rect2D,Allocator> rects( vectorAllocator );
-    uint32_t rectCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && rectCount )
-      {
-        rects.resize( rectCount );
-        result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D*>( rects.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( rectCount <= rects.size() );
-      rects.resize( rectCount );
-    }
-    return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getPresentRectanglesKHR" );
+    d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
+  {
+    d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
+  {
+    d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
+  {
+    d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d) const
   {
-    d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( pMultisampleProperties ) );
+    d.vkUpdateDescriptorSets( m_device, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ), descriptorCopyCount, reinterpret_cast<const VkCopyDescriptorSet*>( pDescriptorCopies ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE MultisamplePropertiesEXT PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies, Dispatch const &d ) const
   {
-    MultisamplePropertiesEXT multisampleProperties;
-    d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( &multisampleProperties ) );
-    return multisampleProperties;
+    d.vkUpdateDescriptorSets( m_device, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ), descriptorCopies.size() , reinterpret_cast<const VkCopyDescriptorSet*>( descriptorCopies.data() ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( pSurfaceCapabilities ) ) );
+    return static_cast<Result>( d.vkWaitForFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ), static_cast<VkBool32>( waitAll ), timeout ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2KHR>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
+  VULKAN_HPP_INLINE Result Device::waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d ) const
   {
-    SurfaceCapabilities2KHR surfaceCapabilities;
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
-    return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
-  }
-  template <typename X, typename Y, typename ...Z, typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
-  {
-    StructureChain<X, Y, Z...> structureChain;
-    SurfaceCapabilities2KHR& surfaceCapabilities = structureChain.template get<SurfaceCapabilities2KHR>();
-    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
-    return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( pSurfaceFormats ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
-  {
-    std::vector<SurfaceFormat2KHR,Allocator> surfaceFormats;
-    uint32_t surfaceFormatCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
-      {
-        surfaceFormats.resize( surfaceFormatCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( surfaceFormats.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
-      surfaceFormats.resize( surfaceFormatCount );
-    }
-    return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormats2KHR" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<SurfaceFormat2KHR,Allocator> surfaceFormats( vectorAllocator );
-    uint32_t surfaceFormatCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
-      {
-        surfaceFormats.resize( surfaceFormatCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( surfaceFormats.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
-      surfaceFormats.resize( surfaceFormatCount );
-    }
-    return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormats2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayProperties2KHR( uint32_t* pPropertyCount, DisplayProperties2KHR* pProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayProperties2KHR*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayProperties2KHR(Dispatch const &d ) const
-  {
-    std::vector<DisplayProperties2KHR,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayProperties2KHR" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<DisplayProperties2KHR,Allocator> properties( vectorAllocator );
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayProperties2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, DisplayPlaneProperties2KHR* pProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayPlaneProperties2KHR(Dispatch const &d ) const
-  {
-    std::vector<DisplayPlaneProperties2KHR,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneProperties2KHR" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayPlaneProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<DisplayPlaneProperties2KHR,Allocator> properties( vectorAllocator );
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneProperties2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModeProperties2KHR* pProperties, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const &d ) const
-  {
-    std::vector<DisplayModeProperties2KHR,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModeProperties2KHR" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<DisplayModeProperties2KHR,Allocator> properties( vectorAllocator );
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
-      properties.resize( propertyCount );
-    }
-    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModeProperties2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR* pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( pDisplayPlaneInfo ), reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( pCapabilities ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DisplayPlaneCapabilities2KHR>::type PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d ) const
-  {
-    DisplayPlaneCapabilities2KHR capabilities;
-    Result result = static_cast<Result>( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( &displayPlaneInfo ), reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( &capabilities ) ) );
-    return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilities2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( pTimeDomains ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type PhysicalDevice::getCalibrateableTimeDomainsEXT(Dispatch const &d ) const
-  {
-    std::vector<TimeDomainEXT,Allocator> timeDomains;
-    uint32_t timeDomainCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && timeDomainCount )
-      {
-        timeDomains.resize( timeDomainCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( timeDomains.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
-      timeDomains.resize( timeDomainCount );
-    }
-    return createResultValue( result, timeDomains, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type PhysicalDevice::getCalibrateableTimeDomainsEXT(Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<TimeDomainEXT,Allocator> timeDomains( vectorAllocator );
-    uint32_t timeDomainCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && timeDomainCount )
-      {
-        timeDomains.resize( timeDomainCount );
-        result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( timeDomains.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
-      timeDomains.resize( timeDomainCount );
-    }
-    return createResultValue( result, timeDomains, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  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 )
-      : objectTable( objectTable_ )
-      , indirectCommandsLayout( indirectCommandsLayout_ )
-      , indirectCommandsTokenCount( indirectCommandsTokenCount_ )
-      , pIndirectCommandsTokens( pIndirectCommandsTokens_ )
-      , maxSequencesCount( maxSequencesCount_ )
-      , targetCommandBuffer( targetCommandBuffer_ )
-      , sequencesCountBuffer( sequencesCountBuffer_ )
-      , sequencesCountOffset( sequencesCountOffset_ )
-      , sequencesIndexBuffer( sequencesIndexBuffer_ )
-      , sequencesIndexOffset( sequencesIndexOffset_ )
-    {
-    }
-
-    CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) );
-    }
-
-    CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) );
-      return *this;
-    }
-    CmdProcessCommandsInfoNVX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setObjectTable( ObjectTableNVX objectTable_ )
-    {
-      objectTable = objectTable_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ )
-    {
-      indirectCommandsLayout = indirectCommandsLayout_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setIndirectCommandsTokenCount( uint32_t indirectCommandsTokenCount_ )
-    {
-      indirectCommandsTokenCount = indirectCommandsTokenCount_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setPIndirectCommandsTokens( const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ )
-    {
-      pIndirectCommandsTokens = pIndirectCommandsTokens_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setMaxSequencesCount( uint32_t maxSequencesCount_ )
-    {
-      maxSequencesCount = maxSequencesCount_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setTargetCommandBuffer( CommandBuffer targetCommandBuffer_ )
-    {
-      targetCommandBuffer = targetCommandBuffer_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setSequencesCountBuffer( Buffer sequencesCountBuffer_ )
-    {
-      sequencesCountBuffer = sequencesCountBuffer_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setSequencesCountOffset( DeviceSize sequencesCountOffset_ )
-    {
-      sequencesCountOffset = sequencesCountOffset_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ )
-    {
-      sequencesIndexBuffer = sequencesIndexBuffer_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ )
-    {
-      sequencesIndexOffset = sequencesIndexOffset_;
-      return *this;
-    }
-
-    operator VkCmdProcessCommandsInfoNVX const&() const
-    {
-      return *reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>(this);
-    }
-
-    operator VkCmdProcessCommandsInfoNVX &()
-    {
-      return *reinterpret_cast<VkCmdProcessCommandsInfoNVX*>(this);
-    }
-
-    bool operator==( CmdProcessCommandsInfoNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( objectTable == rhs.objectTable )
-          && ( indirectCommandsLayout == rhs.indirectCommandsLayout )
-          && ( indirectCommandsTokenCount == rhs.indirectCommandsTokenCount )
-          && ( pIndirectCommandsTokens == rhs.pIndirectCommandsTokens )
-          && ( maxSequencesCount == rhs.maxSequencesCount )
-          && ( targetCommandBuffer == rhs.targetCommandBuffer )
-          && ( sequencesCountBuffer == rhs.sequencesCountBuffer )
-          && ( sequencesCountOffset == rhs.sequencesCountOffset )
-          && ( sequencesIndexBuffer == rhs.sequencesIndexBuffer )
-          && ( sequencesIndexOffset == rhs.sequencesIndexOffset );
-    }
-
-    bool operator!=( CmdProcessCommandsInfoNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCmdProcessCommandsInfoNVX;
-
-  public:
-    const void* pNext = nullptr;
-    ObjectTableNVX objectTable;
-    IndirectCommandsLayoutNVX indirectCommandsLayout;
-    uint32_t indirectCommandsTokenCount;
-    const IndirectCommandsTokenNVX* pIndirectCommandsTokens;
-    uint32_t maxSequencesCount;
-    CommandBuffer targetCommandBuffer;
-    Buffer sequencesCountBuffer;
-    DeviceSize sequencesCountOffset;
-    Buffer sequencesIndexBuffer;
-    DeviceSize sequencesIndexOffset;
-  };
-  static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceGroupProperties
-  {
-    operator VkPhysicalDeviceGroupProperties const&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceGroupProperties*>(this);
-    }
-
-    operator VkPhysicalDeviceGroupProperties &()
-    {
-      return *reinterpret_cast<VkPhysicalDeviceGroupProperties*>(this);
-    }
-
-    bool operator==( PhysicalDeviceGroupProperties const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( physicalDeviceCount == rhs.physicalDeviceCount )
-          && ( memcmp( physicalDevices, rhs.physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof( PhysicalDevice ) ) == 0 )
-          && ( subsetAllocation == rhs.subsetAllocation );
-    }
-
-    bool operator!=( PhysicalDeviceGroupProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceGroupProperties;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t physicalDeviceCount;
-    PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
-    Bool32 subsetAllocation;
-  };
-  static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "struct and wrapper have different size!" );
-
-  using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  class Instance;
-
-  template <typename Dispatch> class UniqueHandleTraits<DebugReportCallbackEXT,Dispatch> {public: using deleter = ObjectDestroy<Instance,Dispatch>; };
-  using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<DebugUtilsMessengerEXT,Dispatch> {public: using deleter = ObjectDestroy<Instance,Dispatch>; };
-  using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT,DispatchLoaderStatic>;
-  template <typename Dispatch> class UniqueHandleTraits<SurfaceKHR,Dispatch> {public: using deleter = ObjectDestroy<Instance,Dispatch>; };
-  using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR,DispatchLoaderStatic>;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  class Instance
-  {
-  public:
-    VULKAN_HPP_CONSTEXPR Instance()
-      : m_instance(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t )
-      : m_instance(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance )
-      : m_instance( instance )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Instance & operator=(VkInstance instance)
-    {
-      m_instance = instance;
-      return *this; 
-    }
-#endif
-
-    Instance & operator=( std::nullptr_t )
-    {
-      m_instance = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Instance const & rhs ) const
-    {
-      return m_instance == rhs.m_instance;
-    }
-
-    bool operator!=(Instance const & rhs ) const
-    {
-      return m_instance != rhs.m_instance;
-    }
-
-    bool operator<(Instance const & rhs ) const
-    {
-      return m_instance < rhs.m_instance;
-    }
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<PhysicalDevice>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices(Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<PhysicalDevice>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices(Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SurfaceKHR>::type createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SurfaceKHR>::type createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SurfaceKHR>::type createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SurfaceKHR>::type createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SurfaceKHR>::type createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SurfaceKHR>::type createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SurfaceKHR>::type createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#ifdef VK_USE_PLATFORM_FUCHSIA
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SurfaceKHR>::type createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<DebugReportCallbackEXT>::type createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<DebugReportCallbackEXT,Dispatch>>::type createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroups(Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroups(Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroupsKHR(Dispatch const &d = Dispatch() ) const;
-    template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic> 
-    typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroupsKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SurfaceKHR>::type createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<SurfaceKHR>::type createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    Result createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugUtilsMessengerEXT* pMessenger, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    ResultValueType<DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template<typename Dispatch = DispatchLoaderStatic>
-    typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT,Dispatch>>::type createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void destroy( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    template<typename Dispatch = DispatchLoaderStatic>
-    void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d = Dispatch() ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template<typename Dispatch = DispatchLoaderStatic>
-    void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d = Dispatch() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const
-    {
-      return m_instance;
-    }
-
-    explicit operator bool() const
-    {
-      return m_instance != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_instance == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkInstance m_instance;
-  };
-
-  static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" );
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( pPhysicalDevices ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type Instance::enumeratePhysicalDevices(Dispatch const &d ) const
-  {
-    std::vector<PhysicalDevice,Allocator> physicalDevices;
-    uint32_t physicalDeviceCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && physicalDeviceCount )
-      {
-        physicalDevices.resize( physicalDeviceCount );
-        result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( physicalDevices.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
-      physicalDevices.resize( physicalDeviceCount );
-    }
-    return createResultValue( result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDevices" );
-  }
-  template <typename Allocator, typename Dispatch> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type Instance::enumeratePhysicalDevices(Allocator const& vectorAllocator, Dispatch const &d ) const
-  {
-    std::vector<PhysicalDevice,Allocator> physicalDevices( vectorAllocator );
-    uint32_t physicalDeviceCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && physicalDeviceCount )
-      {
-        physicalDevices.resize( physicalDeviceCount );
-        result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( physicalDevices.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    if ( result == Result::eSuccess )
-    {
-      VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
-      physicalDevices.resize( physicalDeviceCount );
-    }
-    return createResultValue( result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDevices" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char* pName, Dispatch const &d) const
-  {
-    return d.vkGetInstanceProcAddr( m_instance, pName );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name, Dispatch const &d ) const
-  {
-    return d.vkGetInstanceProcAddr( m_instance, name.c_str() );
+    Result result = static_cast<Result>( d.vkWaitForFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ), static_cast<VkBool32>( waitAll ), timeout ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitForFences", { Result::eSuccess, Result::eTimeout } );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -48159,6 +50512,58 @@ public:
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDebugReportCallbackEXT*>( pCallback ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<DebugReportCallbackEXT>::type Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    DebugReportCallbackEXT callback;
+    Result result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) );
+    return createResultValue( result, callback, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugReportCallbackEXT" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DebugReportCallbackEXT,Dispatch>>::type Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    DebugReportCallbackEXT callback;
+    Result result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) );
+
+    ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<DebugReportCallbackEXT,Dispatch>( result, callback, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugReportCallbackEXTUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugUtilsMessengerEXT* pMessenger, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( pMessenger ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<DebugUtilsMessengerEXT>::type Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    DebugUtilsMessengerEXT messenger;
+    Result result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( &messenger ) ) );
+    return createResultValue( result, messenger, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugUtilsMessengerEXT" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT,Dispatch>>::type Instance::createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    DebugUtilsMessengerEXT messenger;
+    Result result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( &messenger ) ) );
+
+    ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<DebugUtilsMessengerEXT,Dispatch>( result, messenger, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugUtilsMessengerEXTUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template<typename Dispatch>
   VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
   {
@@ -48185,31 +50590,89 @@ public:
 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VK_USE_PLATFORM_IOS_MVK
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
   {
-    d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+    return static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+    SurfaceKHR surface;
+    Result result = static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createIOSSurfaceMVK" );
   }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    SurfaceKHR surface;
+    Result result = static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
+    ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createIOSSurfaceMVKUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
   {
-    d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+    return static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+    SurfaceKHR surface;
+    Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createImagePipeSurfaceFUCHSIA" );
   }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    SurfaceKHR surface;
+    Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
+
+    ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createImagePipeSurfaceFUCHSIAUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    SurfaceKHR surface;
+    Result result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMacOSSurfaceMVK" );
+  }
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    SurfaceKHR surface;
+    Result result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
+
+    ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
+    return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMacOSSurfaceMVKUnique", deleter );
+  }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
 
 #ifdef VK_USE_PLATFORM_VI_NN
   template<typename Dispatch>
@@ -48295,34 +50758,6 @@ public:
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXlibSurfaceKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
-    ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXlibSurfaceKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
 #ifdef VK_USE_PLATFORM_XCB_KHR
   template<typename Dispatch>
   VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
@@ -48351,58 +50786,53 @@ public:
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_XCB_KHR*/
 
-#ifdef VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_XLIB_KHR
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
+    return static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     SurfaceKHR surface;
-    Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createImagePipeSurfaceFUCHSIA" );
+    Result result = static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXlibSurfaceKHR" );
   }
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
     SurfaceKHR surface;
-    Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
+    Result result = static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
 
     ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createImagePipeSurfaceFUCHSIAUnique", deleter );
+    return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXlibSurfaceKHRUnique", deleter );
   }
 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDebugReportCallbackEXT*>( pCallback ) ) );
+    d.vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, pLayerPrefix, pMessage );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DebugReportCallbackEXT>::type Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d ) const
   {
-    DebugReportCallbackEXT callback;
-    Result result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) );
-    return createResultValue( result, callback, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugReportCallbackEXT" );
+#ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( layerPrefix.size() == message.size() );
+#else
+    if ( layerPrefix.size() != message.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::VkInstance::debugReportMessageEXT: layerPrefix.size() != message.size()" );
+    }
+#endif  /*VULKAN_HPP_NO_EXCEPTIONS*/
+    d.vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, layerPrefix.c_str(), message.c_str() );
   }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DebugReportCallbackEXT,Dispatch>>::type Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    DebugReportCallbackEXT callback;
-    Result result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) );
-
-    ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<DebugReportCallbackEXT,Dispatch>( result, callback, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugReportCallbackEXTUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
@@ -48432,23 +50862,67 @@ public:
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d) const
+  VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d) const
   {
-    d.vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, pLayerPrefix, pMessage );
+    d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d ) const
+  VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( layerPrefix.size() == message.size() );
-#else
-    if ( layerPrefix.size() != message.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Instance::debugReportMessageEXT: layerPrefix.size() != message.size()" );
-    }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    d.vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, layerPrefix.c_str(), message.c_str() );
+    d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  {
+    d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  {
+    d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -48458,7 +50932,7 @@ public:
     return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( pPhysicalDeviceGroupProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
+  template<typename Allocator, typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type Instance::enumeratePhysicalDeviceGroups(Dispatch const &d ) const
   {
     std::vector<PhysicalDeviceGroupProperties,Allocator> physicalDeviceGroupProperties;
@@ -48480,7 +50954,7 @@ public:
     }
     return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroups" );
   }
-  template <typename Allocator, typename Dispatch> 
+  template<typename Allocator, typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type Instance::enumeratePhysicalDeviceGroups(Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<PhysicalDeviceGroupProperties,Allocator> physicalDeviceGroupProperties( vectorAllocator );
@@ -48510,7 +50984,7 @@ public:
     return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( pPhysicalDeviceGroupProperties ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator, typename Dispatch> 
+  template<typename Allocator, typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type Instance::enumeratePhysicalDeviceGroupsKHR(Dispatch const &d ) const
   {
     std::vector<PhysicalDeviceGroupProperties,Allocator> physicalDeviceGroupProperties;
@@ -48532,7 +51006,7 @@ public:
     }
     return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroupsKHR" );
   }
-  template <typename Allocator, typename Dispatch> 
+  template<typename Allocator, typename Dispatch>
   VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type Instance::enumeratePhysicalDeviceGroupsKHR(Allocator const& vectorAllocator, Dispatch const &d ) const
   {
     std::vector<PhysicalDeviceGroupProperties,Allocator> physicalDeviceGroupProperties( vectorAllocator );
@@ -48556,111 +51030,68 @@ public:
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#ifdef VK_USE_PLATFORM_IOS_MVK
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+  VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
+    return static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( pPhysicalDevices ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type Instance::enumeratePhysicalDevices(Dispatch const &d ) const
   {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createIOSSurfaceMVK" );
+    std::vector<PhysicalDevice,Allocator> physicalDevices;
+    uint32_t physicalDeviceCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && physicalDeviceCount )
+      {
+        physicalDevices.resize( physicalDeviceCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( physicalDevices.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
+      physicalDevices.resize( physicalDeviceCount );
+    }
+    return createResultValue( result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDevices" );
   }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type Instance::enumeratePhysicalDevices(Allocator const& vectorAllocator, Dispatch const &d ) const
   {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
-    ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createIOSSurfaceMVKUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMacOSSurfaceMVK" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
-    ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMacOSSurfaceMVKUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE Result Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugUtilsMessengerEXT* pMessenger, Dispatch const &d) const
-  {
-    return static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( pMessenger ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<DebugUtilsMessengerEXT>::type Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    DebugUtilsMessengerEXT messenger;
-    Result result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( &messenger ) ) );
-    return createResultValue( result, messenger, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugUtilsMessengerEXT" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT,Dispatch>>::type Instance::createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    DebugUtilsMessengerEXT messenger;
-    Result result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( &messenger ) ) );
-
-    ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
-    return createResultValue<DebugUtilsMessengerEXT,Dispatch>( result, messenger, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugUtilsMessengerEXTUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d) const
-  {
-    d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
-  {
-    d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+    std::vector<PhysicalDevice,Allocator> physicalDevices( vectorAllocator );
+    uint32_t physicalDeviceCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && physicalDeviceCount )
+      {
+        physicalDevices.resize( physicalDeviceCount );
+        result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( physicalDevices.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
+      physicalDevices.resize( physicalDeviceCount );
+    }
+    return createResultValue( result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDevices" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+  VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char* pName, Dispatch const &d) const
   {
-    d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
+    return d.vkGetInstanceProcAddr( m_instance, pName );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE void Instance::destroy( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+  VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name, Dispatch const &d ) const
   {
-    d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
+    return d.vkGetInstanceProcAddr( m_instance, name.c_str() );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
@@ -48677,4107 +51108,1962 @@ public:
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-  struct DeviceGroupDeviceCreateInfo
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d) const
   {
-    DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0,
-                                 const PhysicalDevice* pPhysicalDevices_ = nullptr )
-      : physicalDeviceCount( physicalDeviceCount_ )
-      , pPhysicalDevices( pPhysicalDevices_ )
-    {
-    }
-
-    DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfo ) );
-    }
-
-    DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfo ) );
-      return *this;
-    }
-    DeviceGroupDeviceCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupDeviceCreateInfo& setPhysicalDeviceCount( uint32_t physicalDeviceCount_ )
-    {
-      physicalDeviceCount = physicalDeviceCount_;
-      return *this;
-    }
-
-    DeviceGroupDeviceCreateInfo& setPPhysicalDevices( const PhysicalDevice* pPhysicalDevices_ )
-    {
-      pPhysicalDevices = pPhysicalDevices_;
-      return *this;
-    }
-
-    operator VkDeviceGroupDeviceCreateInfo const&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(this);
-    }
-
-    operator VkDeviceGroupDeviceCreateInfo &()
-    {
-      return *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(this);
-    }
-
-    bool operator==( DeviceGroupDeviceCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( physicalDeviceCount == rhs.physicalDeviceCount )
-          && ( pPhysicalDevices == rhs.pPhysicalDevices );
-    }
-
-    bool operator!=( DeviceGroupDeviceCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t physicalDeviceCount;
-    const PhysicalDevice* pPhysicalDevices;
-  };
-  static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "struct and wrapper have different size!" );
-
-  using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-
-  template <typename Dispatch> class UniqueHandleTraits<Instance,Dispatch> {public: using deleter = ObjectDestroy<NoParent,Dispatch>; };
-  using UniqueInstance = UniqueHandle<Instance,DispatchLoaderStatic>;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  template<typename Dispatch = DispatchLoaderStatic>
-  Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d = Dispatch() );
+    return static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast<VkDisplayKHR>( display ) ) );
+  }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template<typename Dispatch = DispatchLoaderStatic>
-  ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() );
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template<typename Dispatch = DispatchLoaderStatic>
-  typename ResultValueType<UniqueHandle<Instance,Dispatch>>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() );
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<Display>::type PhysicalDevice::acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d ) const
+  {
+    Display dpy;
+    Result result = static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) );
+    return createResultValue( result, dpy, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::acquireXlibDisplayEXT" );
+  }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
 
   template<typename Dispatch>
-  VULKAN_HPP_INLINE Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d)
+  VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d) const
   {
-    return static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkInstance*>( pInstance ) ) );
+    return static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDevice*>( pDevice ) ) );
   }
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d )
+  VULKAN_HPP_INLINE ResultValueType<Device>::type PhysicalDevice::createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Instance instance;
-    Result result = static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) );
-    return createResultValue( result, instance, VULKAN_HPP_NAMESPACE_STRING"::createInstance" );
+    Device device;
+    Result result = static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) );
+    return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDevice" );
   }
 #ifndef VULKAN_HPP_NO_SMART_HANDLE
   template<typename Dispatch>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Instance,Dispatch>>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d )
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Device,Dispatch>>::type PhysicalDevice::createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    Instance instance;
-    Result result = static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) );
+    Device device;
+    Result result = static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) );
 
     ObjectDestroy<NoParent,Dispatch> deleter( allocator, d );
-    return createResultValue<Instance,Dispatch>( result, instance, VULKAN_HPP_NAMESPACE_STRING"::createInstanceUnique", deleter );
+    return createResultValue<Device,Dispatch>( result, device, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDeviceUnique", deleter );
   }
 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-
-  struct BaseOutStructure
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d) const
   {
-    BaseOutStructure(  )
-    {
-    }
-
-    BaseOutStructure( VkBaseOutStructure const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BaseOutStructure ) );
-    }
-
-    BaseOutStructure& operator=( VkBaseOutStructure const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BaseOutStructure ) );
-      return *this;
-    }
-    BaseOutStructure& setPNext( struct BaseOutStructure* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    operator VkBaseOutStructure const&() const
-    {
-      return *reinterpret_cast<const VkBaseOutStructure*>(this);
-    }
-
-    operator VkBaseOutStructure &()
-    {
-      return *reinterpret_cast<VkBaseOutStructure*>(this);
-    }
-
-    bool operator==( BaseOutStructure const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext );
-    }
-
-    bool operator!=( BaseOutStructure const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    StructureType sType;
-    struct BaseOutStructure* pNext = nullptr;
-  };
-  static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "struct and wrapper have different size!" );
-
-  struct BaseInStructure
+    return static_cast<Result>( d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDisplayModeKHR*>( pMode ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<DisplayModeKHR>::type PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
   {
-    BaseInStructure(  )
-    {
-    }
+    DisplayModeKHR mode;
+    Result result = static_cast<Result>( d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDisplayModeKHR*>( &mode ) ) );
+    return createResultValue( result, mode, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDisplayModeKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    BaseInStructure( VkBaseInStructure const & rhs )
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName, Dispatch const &d ) const
+  {
+    std::vector<ExtensionProperties,Allocator> properties;
+    uint32_t propertyCount;
+    Result result;
+    do
     {
-      memcpy( this, &rhs, sizeof( BaseInStructure ) );
-    }
-
-    BaseInStructure& operator=( VkBaseInStructure const & rhs )
+      result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
     {
-      memcpy( this, &rhs, sizeof( BaseInStructure ) );
-      return *this;
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
     }
-    BaseInStructure& setPNext( const struct BaseInStructure* pNext_ )
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceExtensionProperties" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<ExtensionProperties,Allocator> properties( vectorAllocator );
+    uint32_t propertyCount;
+    Result result;
+    do
     {
-      pNext = pNext_;
-      return *this;
-    }
-
-    operator VkBaseInStructure const&() const
+      result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
     {
-      return *reinterpret_cast<const VkBaseInStructure*>(this);
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
     }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceExtensionProperties" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    operator VkBaseInStructure &()
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type PhysicalDevice::enumerateDeviceLayerProperties(Dispatch const &d ) const
+  {
+    std::vector<LayerProperties,Allocator> properties;
+    uint32_t propertyCount;
+    Result result;
+    do
     {
-      return *reinterpret_cast<VkBaseInStructure*>(this);
-    }
-
-    bool operator==( BaseInStructure const& rhs ) const
+      result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
     {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext );
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
     }
-
-    bool operator!=( BaseInStructure const& rhs ) const
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceLayerProperties" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type PhysicalDevice::enumerateDeviceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<LayerProperties,Allocator> properties( vectorAllocator );
+    uint32_t propertyCount;
+    Result result;
+    do
     {
-      return !operator==( rhs );
+      result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
     }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceLayerProperties" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    StructureType sType;
-    const struct BaseInStructure* pNext = nullptr;
-  };
-  static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" );
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModeProperties2KHR* pProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( pProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const &d ) const
+  {
+    std::vector<DisplayModeProperties2KHR,Allocator> properties;
+    uint32_t propertyCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModeProperties2KHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<DisplayModeProperties2KHR,Allocator> properties( vectorAllocator );
+    uint32_t propertyCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModeProperties2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( pProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const &d ) const
+  {
+    std::vector<DisplayModePropertiesKHR,Allocator> properties;
+    uint32_t propertyCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModePropertiesKHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<DisplayModePropertiesKHR,Allocator> properties( vectorAllocator );
+    uint32_t propertyCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModePropertiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR* pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( pDisplayPlaneInfo ), reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( pCapabilities ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<DisplayPlaneCapabilities2KHR>::type PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d ) const
+  {
+    DisplayPlaneCapabilities2KHR capabilities;
+    Result result = static_cast<Result>( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( &displayPlaneInfo ), reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( &capabilities ) ) );
+    return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilities2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( pCapabilities ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<DisplayPlaneCapabilitiesKHR>::type PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d ) const
+  {
+    DisplayPlaneCapabilitiesKHR capabilities;
+    Result result = static_cast<Result>( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( &capabilities ) ) );
+    return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR*>( pDisplays ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const &d ) const
+  {
+    std::vector<DisplayKHR,Allocator> displays;
+    uint32_t displayCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && displayCount )
+      {
+        displays.resize( displayCount );
+        result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR*>( displays.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( displayCount <= displays.size() );
+      displays.resize( displayCount );
+    }
+    return createResultValue( result, displays, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<DisplayKHR,Allocator> displays( vectorAllocator );
+    uint32_t displayCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && displayCount )
+      {
+        displays.resize( displayCount );
+        result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR*>( displays.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( displayCount <= displays.size() );
+      displays.resize( displayCount );
+    }
+    return createResultValue( result, displays, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( pTimeDomains ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type PhysicalDevice::getCalibrateableTimeDomainsEXT(Dispatch const &d ) const
+  {
+    std::vector<TimeDomainEXT,Allocator> timeDomains;
+    uint32_t timeDomainCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && timeDomainCount )
+      {
+        timeDomains.resize( timeDomainCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( timeDomains.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
+      timeDomains.resize( timeDomainCount );
+    }
+    return createResultValue( result, timeDomains, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type PhysicalDevice::getCalibrateableTimeDomainsEXT(Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<TimeDomainEXT,Allocator> timeDomains( vectorAllocator );
+    uint32_t timeDomainCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && timeDomainCount )
+      {
+        timeDomains.resize( timeDomainCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( timeDomains.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
+      timeDomains.resize( timeDomainCount );
+    }
+    return createResultValue( result, timeDomains, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, DisplayPlaneProperties2KHR* pProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR*>( pProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayPlaneProperties2KHR(Dispatch const &d ) const
+  {
+    std::vector<DisplayPlaneProperties2KHR,Allocator> properties;
+    uint32_t propertyCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneProperties2KHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayPlaneProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<DisplayPlaneProperties2KHR,Allocator> properties( vectorAllocator );
+    uint32_t propertyCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneProperties2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( pProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPlanePropertiesKHR(Dispatch const &d ) const
+  {
+    std::vector<DisplayPlanePropertiesKHR,Allocator> properties;
+    uint32_t propertyCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlanePropertiesKHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPlanePropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<DisplayPlanePropertiesKHR,Allocator> properties( vectorAllocator );
+    uint32_t propertyCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlanePropertiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayProperties2KHR( uint32_t* pPropertyCount, DisplayProperties2KHR* pProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayProperties2KHR*>( pProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayProperties2KHR(Dispatch const &d ) const
+  {
+    std::vector<DisplayProperties2KHR,Allocator> properties;
+    uint32_t propertyCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayProperties2KHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<DisplayProperties2KHR,Allocator> properties( vectorAllocator );
+    uint32_t propertyCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayProperties2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( pProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPropertiesKHR(Dispatch const &d ) const
+  {
+    std::vector<DisplayPropertiesKHR,Allocator> properties;
+    uint32_t propertyCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPropertiesKHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<DisplayPropertiesKHR,Allocator> properties( vectorAllocator );
+    uint32_t propertyCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      properties.resize( propertyCount );
+    }
+    return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPropertiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ExternalBufferProperties PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const
+  {
+    ExternalBufferProperties externalBufferProperties;
+    d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
+    return externalBufferProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ExternalBufferProperties PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const
+  {
+    ExternalBufferProperties externalBufferProperties;
+    d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
+    return externalBufferProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ExternalFenceProperties PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const
+  {
+    ExternalFenceProperties externalFenceProperties;
+    d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
+    return externalFenceProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ExternalFenceProperties PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const
+  {
+    ExternalFenceProperties externalFenceProperties;
+    d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
+    return externalFenceProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( pExternalImageFormatProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<ExternalImageFormatPropertiesNV>::type PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d ) const
+  {
+    ExternalImageFormatPropertiesNV externalImageFormatProperties;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( &externalImageFormatProperties ) ) );
+    return createResultValue( result, externalImageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getExternalImageFormatPropertiesNV" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const
+  {
+    ExternalSemaphoreProperties externalSemaphoreProperties;
+    d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
+    return externalSemaphoreProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const
+  {
+    ExternalSemaphoreProperties externalSemaphoreProperties;
+    d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
+    return externalSemaphoreProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( PhysicalDeviceFeatures* pFeatures, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( pFeatures ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE PhysicalDeviceFeatures PhysicalDevice::getFeatures(Dispatch const &d ) const
+  {
+    PhysicalDeviceFeatures features;
+    d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( &features ) );
+    return features;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2(Dispatch const &d ) const
+  {
+    PhysicalDeviceFeatures2 features;
+    d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
+    return features;
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2(Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
+    d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
+  {
+    PhysicalDeviceFeatures2 features;
+    d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
+    return features;
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
+    d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties( Format format, FormatProperties* pFormatProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( pFormatProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE FormatProperties PhysicalDevice::getFormatProperties( Format format, Dispatch const &d ) const
+  {
+    FormatProperties formatProperties;
+    d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( &formatProperties ) );
+    return formatProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2( Format format, FormatProperties2* pFormatProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2( Format format, Dispatch const &d ) const
+  {
+    FormatProperties2 formatProperties;
+    d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
+    return formatProperties;
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2( Format format, Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    FormatProperties2& formatProperties = structureChain.template get<FormatProperties2>();
+    d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( Format format, FormatProperties2* pFormatProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2KHR( Format format, Dispatch const &d ) const
+  {
+    FormatProperties2 formatProperties;
+    d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
+    return formatProperties;
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2KHR( Format format, Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    FormatProperties2& formatProperties = structureChain.template get<FormatProperties2>();
+    d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( pFeatures ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( pLimits ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE DeviceGeneratedCommandsLimitsNVX PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d ) const
+  {
+    DeviceGeneratedCommandsLimitsNVX limits;
+    d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( &features ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( &limits ) );
+    return limits;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), reinterpret_cast<VkImageFormatProperties*>( pImageFormatProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties>::type PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const &d ) const
+  {
+    ImageFormatProperties imageFormatProperties;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), reinterpret_cast<VkImageFormatProperties*>( &imageFormatProperties ) ) );
+    return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
+  {
+    ImageFormatProperties2 imageFormatProperties;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
+    return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
+    return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
+  {
+    ImageFormatProperties2 imageFormatProperties;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
+    return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
+    return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( pMemoryProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties(Dispatch const &d ) const
+  {
+    PhysicalDeviceMemoryProperties memoryProperties;
+    d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( &memoryProperties ) );
+    return memoryProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2(Dispatch const &d ) const
+  {
+    PhysicalDeviceMemoryProperties2 memoryProperties;
+    d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
+    return memoryProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const
+  {
+    PhysicalDeviceMemoryProperties2 memoryProperties;
+    d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
+    return memoryProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( pMultisampleProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE MultisamplePropertiesEXT PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const &d ) const
+  {
+    MultisamplePropertiesEXT multisampleProperties;
+    d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( &multisampleProperties ) );
+    return multisampleProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pRectCount, reinterpret_cast<VkRect2D*>( pRects ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const &d ) const
+  {
+    std::vector<Rect2D,Allocator> rects;
+    uint32_t rectCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && rectCount )
+      {
+        rects.resize( rectCount );
+        result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D*>( rects.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( rectCount <= rects.size() );
+      rects.resize( rectCount );
+    }
+    return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getPresentRectanglesKHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<Rect2D,Allocator> rects( vectorAllocator );
+    uint32_t rectCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && rectCount )
+      {
+        rects.resize( rectCount );
+        result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D*>( rects.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( rectCount <= rects.size() );
+      rects.resize( rectCount );
+    }
+    return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getPresentRectanglesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getProperties( PhysicalDeviceProperties* pProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( pProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE PhysicalDeviceProperties PhysicalDevice::getProperties(Dispatch const &d ) const
+  {
+    PhysicalDeviceProperties properties;
+    d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
+    return properties;
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties(Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    PhysicalDeviceProperties& properties = structureChain.template get<PhysicalDeviceProperties>();
+    d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( PhysicalDeviceProperties2* pProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2(Dispatch const &d ) const
+  {
+    PhysicalDeviceProperties2 properties;
+    d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
+    return properties;
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2(Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
+    d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( PhysicalDeviceProperties2* pProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
+  {
+    PhysicalDeviceProperties2 properties;
+    d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
+    return properties;
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
+    d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
+    return structureChain;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( pQueueFamilyProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties,Allocator> PhysicalDevice::getQueueFamilyProperties(Dispatch const &d ) const
+  {
+    std::vector<QueueFamilyProperties,Allocator> queueFamilyProperties;
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( queueFamilyProperties.data() ) );
+    return queueFamilyProperties;
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties,Allocator> PhysicalDevice::getQueueFamilyProperties(Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<QueueFamilyProperties,Allocator> queueFamilyProperties( vectorAllocator );
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( queueFamilyProperties.data() ) );
+    return queueFamilyProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2(Dispatch const &d ) const
+  {
+    std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties;
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+    return queueFamilyProperties;
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties( vectorAllocator );
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+    return queueFamilyProperties;
+  }
+  template<typename StructureChain, typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<StructureChain,Allocator> PhysicalDevice::getQueueFamilyProperties2(Dispatch const &d ) const
+  {
+    std::vector<StructureChain,Allocator> queueFamilyProperties;
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+    return queueFamilyProperties;
+  }
+  template<typename StructureChain, typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<StructureChain,Allocator> PhysicalDevice::getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<StructureChain,Allocator> queueFamilyProperties( vectorAllocator );
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+    return queueFamilyProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2KHR(Dispatch const &d ) const
+  {
+    std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties;
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+    return queueFamilyProperties;
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties( vectorAllocator );
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+    return queueFamilyProperties;
+  }
+  template<typename StructureChain, typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<StructureChain,Allocator> PhysicalDevice::getQueueFamilyProperties2KHR(Dispatch const &d ) const
+  {
+    std::vector<StructureChain,Allocator> queueFamilyProperties;
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+    return queueFamilyProperties;
+  }
+  template<typename StructureChain, typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<StructureChain,Allocator> PhysicalDevice::getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<StructureChain,Allocator> queueFamilyProperties( vectorAllocator );
+    uint32_t queueFamilyPropertyCount;
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
+    queueFamilyProperties.resize( queueFamilyPropertyCount );
+    d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+    return queueFamilyProperties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( pProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d ) const
+  {
+    std::vector<SparseImageFormatProperties,Allocator> properties;
+    uint32_t propertyCount;
+    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, nullptr );
+    properties.resize( propertyCount );
+    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( properties.data() ) );
+    return properties;
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<SparseImageFormatProperties,Allocator> properties( vectorAllocator );
+    uint32_t propertyCount;
+    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, nullptr );
+    properties.resize( propertyCount );
+    d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( properties.data() ) );
+    return properties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d ) const
+  {
+    std::vector<SparseImageFormatProperties2,Allocator> properties;
+    uint32_t propertyCount;
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
+    properties.resize( propertyCount );
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
+    return properties;
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<SparseImageFormatProperties2,Allocator> properties( vectorAllocator );
+    uint32_t propertyCount;
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
+    properties.resize( propertyCount );
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
+    return properties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d) const
+  {
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d ) const
+  {
+    std::vector<SparseImageFormatProperties2,Allocator> properties;
+    uint32_t propertyCount;
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
+    properties.resize( propertyCount );
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
+    return properties;
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<SparseImageFormatProperties2,Allocator> properties( vectorAllocator );
+    uint32_t propertyCount;
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
+    properties.resize( propertyCount );
+    d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
+    return properties;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( pSurfaceCapabilities ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2EXT>::type PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const &d ) const
+  {
+    SurfaceCapabilities2EXT surfaceCapabilities;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( &surfaceCapabilities ) ) );
+    return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2EXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( pSurfaceCapabilities ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2KHR>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
+  {
+    SurfaceCapabilities2KHR surfaceCapabilities;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
+    return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
+  }
+  template<typename X, typename Y, typename ...Z, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
+  {
+    StructureChain<X, Y, Z...> structureChain;
+    SurfaceCapabilities2KHR& surfaceCapabilities = structureChain.template get<SurfaceCapabilities2KHR>();
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
+    return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( pSurfaceCapabilities ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilitiesKHR>::type PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const &d ) const
+  {
+    SurfaceCapabilitiesKHR surfaceCapabilities;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( &surfaceCapabilities ) ) );
+    return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilitiesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( pSurfaceFormats ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
+  {
+    std::vector<SurfaceFormat2KHR,Allocator> surfaceFormats;
+    uint32_t surfaceFormatCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
+      {
+        surfaceFormats.resize( surfaceFormatCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( surfaceFormats.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+      surfaceFormats.resize( surfaceFormatCount );
+    }
+    return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormats2KHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<SurfaceFormat2KHR,Allocator> surfaceFormats( vectorAllocator );
+    uint32_t surfaceFormatCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
+      {
+        surfaceFormats.resize( surfaceFormatCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( surfaceFormats.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+      surfaceFormats.resize( surfaceFormatCount );
+    }
+    return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormats2KHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( pSurfaceFormats ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const &d ) const
+  {
+    std::vector<SurfaceFormatKHR,Allocator> surfaceFormats;
+    uint32_t surfaceFormatCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
+      {
+        surfaceFormats.resize( surfaceFormatCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+      surfaceFormats.resize( surfaceFormatCount );
+    }
+    return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormatsKHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<SurfaceFormatKHR,Allocator> surfaceFormats( vectorAllocator );
+    uint32_t surfaceFormatCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
+      {
+        surfaceFormats.resize( surfaceFormatCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
+      surfaceFormats.resize( surfaceFormatCount );
+    }
+    return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormatsKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>( pPresentModes ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d ) const
+  {
+    std::vector<PresentModeKHR,Allocator> presentModes;
+    uint32_t presentModeCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && presentModeCount )
+      {
+        presentModes.resize( presentModeCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
+      presentModes.resize( presentModeCount );
+    }
+    return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModesKHR" );
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<PresentModeKHR,Allocator> presentModes( vectorAllocator );
+    uint32_t presentModeCount;
+    Result result;
+    do
+    {
+      result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
+      if ( ( result == Result::eSuccess ) && presentModeCount )
+      {
+        presentModes.resize( presentModeCount );
+        result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    if ( result == Result::eSuccess )
+    {
+      VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
+      presentModes.resize( presentModeCount );
+    }
+    return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModesKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32*>( pSupported ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<Bool32>::type PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d ) const
+  {
+    Bool32 supported;
+    Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32*>( &supported ) ) );
+    return createResultValue( result, supported, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceSupportKHR" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display, Dispatch const &d) const
+  {
+    return static_cast<Bool32>( d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const &d ) const
+  {
+    return d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
 
-  template <> struct isStructureChainValid<PresentInfoKHR, DisplayPresentInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageCreateInfo, DedicatedAllocationImageCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BufferCreateInfo, DedicatedAllocationBufferCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryAllocateInfo, DedicatedAllocationMemoryAllocateInfoNV>{ enum { value = true }; };
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryWin32HandleInfoNV>{ enum { value = true }; };
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d) const
+  {
+    return static_cast<Bool32>( d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d ) const
+  {
+    return d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<SubmitInfo, Win32KeyedMutexAcquireReleaseInfoNV>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFeatures2>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePushDescriptorPropertiesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PresentInfoKHR, PresentRegionsKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceVariablePointerFeatures>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceVariablePointerFeatures>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceIDProperties>{ enum { value = true }; };
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryWin32HandleInfoKHR>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<SubmitInfo, Win32KeyedMutexAcquireReleaseInfoKHR>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<SemaphoreCreateInfo, ExportSemaphoreWin32HandleInfoKHR>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<SubmitInfo, D3D12FenceSubmitInfoKHR>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<FenceCreateInfo, ExportFenceWin32HandleInfoKHR>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceMultiviewFeatures>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceMultiviewFeatures>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMultiviewProperties>{ enum { value = true }; };
-  template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassMultiviewCreateInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BindBufferMemoryInfo, BindBufferMemoryDeviceGroupInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BindImageMemoryInfo, BindImageMemoryDeviceGroupInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<RenderPassBeginInfo, DeviceGroupRenderPassBeginInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<CommandBufferBeginInfo, DeviceGroupCommandBufferBeginInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SubmitInfo, DeviceGroupSubmitInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BindSparseInfo, DeviceGroupBindSparseInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageCreateInfo, ImageSwapchainCreateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BindImageMemoryInfo, BindImageMemorySwapchainInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PresentInfoKHR, PresentTimesInfoGOOGLE>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportWScalingStateCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceDiscardRectanglePropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDevice16BitStorageFeatures>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDevice16BitStorageFeatures>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryRequirements2, MemoryDedicatedRequirements>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryAllocateInfo, MemoryDedicatedAllocateInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SamplerCreateInfo, SamplerYcbcrConversionInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageViewCreateInfo, SamplerYcbcrConversionInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceSamplerYcbcrConversionFeatures>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceSamplerYcbcrConversionFeatures>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageFormatProperties2, SamplerYcbcrConversionImageFormatProperties>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageFormatProperties2, TextureLODGatherFormatPropertiesAMD>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SubmitInfo, ProtectedSubmitInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceProtectedMemoryFeatures>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceProtectedMemoryFeatures>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceProtectedMemoryProperties>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageToColorStateCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSamplerFilterMinmaxPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceBlendOperationAdvancedFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceBlendOperationAdvancedFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceBlendOperationAdvancedPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceInlineUniformBlockPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<WriteDescriptorSet, WriteDescriptorSetInlineUniformBlockEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DescriptorPoolCreateInfo, DescriptorPoolInlineUniformBlockCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageCreateInfo, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SwapchainCreateInfoKHR, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ShaderModuleCreateInfo, ShaderModuleValidationCacheCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMaintenance3Properties>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderDrawParameterFeatures>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderDrawParameterFeatures>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceExternalMemoryHostPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceConservativeRasterizationPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceShaderCorePropertiesAMD>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceDescriptorIndexingFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceDescriptorIndexingFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceDescriptorIndexingPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DescriptorSetAllocateInfo, DescriptorSetVariableDescriptorCountAllocateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DescriptorSetLayoutSupport, DescriptorSetVariableDescriptorCountLayoutSupportEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineVertexInputStateCreateInfo, PipelineVertexInputDivisorStateCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceVertexAttributeDivisorPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePCIBusInfoPropertiesEXT>{ enum { value = true }; };
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id, Dispatch const &d) const
+  {
+    return static_cast<Bool32>( d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const &d ) const
+  {
+    return d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID, Dispatch const &d) const
+  {
+    return static_cast<Bool32>( d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const &d ) const
+  {
+    return d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( pDisplay ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<DisplayKHR>::type PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d ) const
+  {
+    DisplayKHR display;
+    Result result = static_cast<Result>( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( &display ) ) );
+    return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getRandROutputDisplayEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::releaseDisplayEXT" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t* pCheckpointDataCount, CheckpointDataNV* pCheckpointData, Dispatch const &d) const
+  {
+    d.vkGetQueueCheckpointDataNV( m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV*>( pCheckpointData ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<CheckpointDataNV,Allocator> Queue::getCheckpointDataNV(Dispatch const &d ) const
+  {
+    std::vector<CheckpointDataNV,Allocator> checkpointData;
+    uint32_t checkpointDataCount;
+    d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
+    checkpointData.resize( checkpointDataCount );
+    d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV*>( checkpointData.data() ) );
+    return checkpointData;
+  }
+  template<typename Allocator, typename Dispatch>
+  VULKAN_HPP_INLINE std::vector<CheckpointDataNV,Allocator> Queue::getCheckpointDataNV(Allocator const& vectorAllocator, Dispatch const &d ) const
+  {
+    std::vector<CheckpointDataNV,Allocator> checkpointData( vectorAllocator );
+    uint32_t checkpointDataCount;
+    d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
+    checkpointData.resize( checkpointDataCount );
+    d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV*>( checkpointData.data() ) );
+    return checkpointData;
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
+  {
+    d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const
+  {
+    d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( &labelInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Queue::bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkQueueBindSparse( m_queue, bindInfoCount, reinterpret_cast<const VkBindSparseInfo*>( pBindInfo ), static_cast<VkFence>( fence ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkQueueBindSparse( m_queue, bindInfo.size() , reinterpret_cast<const VkBindSparseInfo*>( bindInfo.data() ), static_cast<VkFence>( fence ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::bindSparse" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT(Dispatch const &d) const
+  {
+    d.vkQueueEndDebugUtilsLabelEXT( m_queue );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT(Dispatch const &d ) const
+  {
+    d.vkQueueEndDebugUtilsLabelEXT( m_queue );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
+  {
+    d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const
+  {
+    d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( &labelInfo ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( pPresentInfo ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( &presentInfo ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR } );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkQueueSubmit( m_queue, submitCount, reinterpret_cast<const VkSubmitInfo*>( pSubmits ), static_cast<VkFence>( fence ) ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::submit( ArrayProxy<const SubmitInfo> submits, Fence fence, Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkQueueSubmit( m_queue, submits.size() , reinterpret_cast<const VkSubmitInfo*>( submits.data() ), static_cast<VkFence>( fence ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::submit" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE Result Queue::waitIdle(Dispatch const &d) const
+  {
+    return static_cast<Result>( d.vkQueueWaitIdle( m_queue ) );
+  }
+#else
+  template<typename Dispatch>
+  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::waitIdle(Dispatch const &d ) const
+  {
+    Result result = static_cast<Result>( d.vkQueueWaitIdle( m_queue ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::waitIdle" );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportAndroidHardwareBufferInfoANDROID>{ enum { value = true }; };
+  template <> struct isStructureChainValid<AndroidHardwareBufferPropertiesANDROID, AndroidHardwareBufferFormatPropertiesANDROID>{ enum { value = true }; };
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   template <> struct isStructureChainValid<ImageFormatProperties2, AndroidHardwareBufferUsageANDROID>{ enum { value = true }; };
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+  template <> struct isStructureChainValid<BindBufferMemoryInfo, BindBufferMemoryDeviceGroupInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<BindImageMemoryInfo, BindImageMemoryDeviceGroupInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<BindImageMemoryInfo, BindImageMemorySwapchainInfoKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<BindImageMemoryInfo, BindImagePlaneMemoryInfo>{ enum { value = true }; };
   template <> struct isStructureChainValid<CommandBufferInheritanceInfo, CommandBufferInheritanceConditionalRenderingInfoEXT>{ enum { value = true }; };
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template <> struct isStructureChainValid<SubmitInfo, D3D12FenceSubmitInfoKHR>{ enum { value = true }; };
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+  template <> struct isStructureChainValid<InstanceCreateInfo, DebugReportCallbackCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<InstanceCreateInfo, DebugUtilsMessengerCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<BufferCreateInfo, DedicatedAllocationBufferCreateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageCreateInfo, DedicatedAllocationImageCreateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<MemoryAllocateInfo, DedicatedAllocationMemoryAllocateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DescriptorPoolCreateInfo, DescriptorPoolInlineUniformBlockCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DescriptorSetLayoutCreateInfo, DescriptorSetLayoutBindingFlagsCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DescriptorSetAllocateInfo, DescriptorSetVariableDescriptorCountAllocateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DescriptorSetLayoutSupport, DescriptorSetVariableDescriptorCountLayoutSupportEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<BindSparseInfo, DeviceGroupBindSparseInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<CommandBufferBeginInfo, DeviceGroupCommandBufferBeginInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, DeviceGroupDeviceCreateInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PresentInfoKHR, DeviceGroupPresentInfoKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<RenderPassBeginInfo, DeviceGroupRenderPassBeginInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<SubmitInfo, DeviceGroupSubmitInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<SwapchainCreateInfoKHR, DeviceGroupSwapchainCreateInfoKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, DeviceMemoryOverallocationCreateInfoAMD>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceQueueCreateInfo, DeviceQueueGlobalPriorityCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PresentInfoKHR, DisplayPresentInfoKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<FormatProperties2, DrmFormatModifierPropertiesListEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<FenceCreateInfo, ExportFenceCreateInfo>{ enum { value = true }; };
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template <> struct isStructureChainValid<FenceCreateInfo, ExportFenceWin32HandleInfoKHR>{ enum { value = true }; };
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+  template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryAllocateInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryAllocateInfoNV>{ enum { value = true }; };
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryWin32HandleInfoKHR>{ enum { value = true }; };
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryWin32HandleInfoNV>{ enum { value = true }; };
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+  template <> struct isStructureChainValid<SemaphoreCreateInfo, ExportSemaphoreCreateInfo>{ enum { value = true }; };
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template <> struct isStructureChainValid<SemaphoreCreateInfo, ExportSemaphoreWin32HandleInfoKHR>{ enum { value = true }; };
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   template <> struct isStructureChainValid<ImageCreateInfo, ExternalFormatANDROID>{ enum { value = true }; };
   template <> struct isStructureChainValid<SamplerYcbcrConversionCreateInfo, ExternalFormatANDROID>{ enum { value = true }; };
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+  template <> struct isStructureChainValid<ImageFormatProperties2, ExternalImageFormatProperties>{ enum { value = true }; };
+  template <> struct isStructureChainValid<BufferCreateInfo, ExternalMemoryBufferCreateInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageCreateInfo, ExternalMemoryImageCreateInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageCreateInfo, ExternalMemoryImageCreateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageCreateInfo, ImageDrmFormatModifierExplicitCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageCreateInfo, ImageDrmFormatModifierListCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageCreateInfo, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<SwapchainCreateInfoKHR, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageMemoryRequirementsInfo2, ImagePlaneMemoryRequirementsInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageCreateInfo, ImageStencilUsageCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, ImageStencilUsageCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageCreateInfo, ImageSwapchainCreateInfoKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewASTCDecodeModeEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewUsageCreateInfo>{ enum { value = true }; };
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportAndroidHardwareBufferInfoANDROID>{ enum { value = true }; };
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryFdInfoKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryHostPointerInfoEXT>{ enum { value = true }; };
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryWin32HandleInfoKHR>{ enum { value = true }; };
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryWin32HandleInfoNV>{ enum { value = true }; };
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+  template <> struct isStructureChainValid<MemoryAllocateInfo, MemoryAllocateFlagsInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<MemoryAllocateInfo, MemoryDedicatedAllocateInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<MemoryRequirements2, MemoryDedicatedRequirements>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDevice16BitStorageFeatures>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDevice16BitStorageFeatures>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDevice8BitStorageFeaturesKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDevice8BitStorageFeaturesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceConditionalRenderingFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceConditionalRenderingFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceVulkanMemoryModelFeaturesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceVulkanMemoryModelFeaturesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderAtomicInt64FeaturesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderAtomicInt64FeaturesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceVertexAttributeDivisorFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceVertexAttributeDivisorFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewASTCDecodeModeEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceASTCDecodeFeaturesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceASTCDecodeFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceTransformFeedbackFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceTransformFeedbackFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceTransformFeedbackPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationStateStreamCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceRepresentativeFragmentTestFeaturesNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceRepresentativeFragmentTestFeaturesNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineRepresentativeFragmentTestStateCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceExclusiveScissorFeaturesNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceExclusiveScissorFeaturesNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportExclusiveScissorStateCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceCornerSampledImageFeaturesNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceCornerSampledImageFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceBlendOperationAdvancedFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceBlendOperationAdvancedFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceBlendOperationAdvancedPropertiesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceComputeShaderDerivativesFeaturesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceComputeShaderDerivativesFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceConditionalRenderingFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceConditionalRenderingFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceConservativeRasterizationPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceCornerSampledImageFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceCornerSampledImageFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceDescriptorIndexingFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceDescriptorIndexingFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceDescriptorIndexingPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceDiscardRectanglePropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceDriverPropertiesKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceExclusiveScissorFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceExclusiveScissorFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceExternalImageFormatInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceExternalMemoryHostPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFeatures2>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceFragmentDensityMapFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFragmentDensityMapFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceFragmentDensityMapPropertiesEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceFragmentShaderBarycentricFeaturesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFragmentShaderBarycentricFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceIDProperties>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceImageDrmFormatModifierInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceInlineUniformBlockPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMaintenance3Properties>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceMeshShaderFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceMeshShaderFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMeshShaderPropertiesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceMultiviewFeatures>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceMultiviewFeatures>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMultiviewProperties>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePCIBusInfoPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePointClippingProperties>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceProtectedMemoryFeatures>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceProtectedMemoryFeatures>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceProtectedMemoryProperties>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePushDescriptorPropertiesKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceRayTracingPropertiesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceRepresentativeFragmentTestFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceRepresentativeFragmentTestFeaturesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSampleLocationsPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSamplerFilterMinmaxPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceSamplerYcbcrConversionFeatures>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceSamplerYcbcrConversionFeatures>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceScalarBlockLayoutFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceScalarBlockLayoutFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderAtomicInt64FeaturesKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderAtomicInt64FeaturesKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceShaderCorePropertiesAMD>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderDrawParameterFeatures>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderDrawParameterFeatures>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderImageFootprintFeaturesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderImageFootprintFeaturesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShadingRateImageFeaturesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShadingRateImageFeaturesNV>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties, PhysicalDeviceShadingRateImagePropertiesNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceMeshShaderFeaturesNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceMeshShaderFeaturesNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMeshShaderPropertiesNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<WriteDescriptorSet, WriteDescriptorSetAccelerationStructureNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceRayTracingPropertiesNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceImageDrmFormatModifierInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageCreateInfo, ImageDrmFormatModifierListCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageCreateInfo, ImageDrmFormatModifierExplicitCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceFragmentDensityMapFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFragmentDensityMapFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceFragmentDensityMapPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassFragmentDensityMapCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceScalarBlockLayoutFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceScalarBlockLayoutFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SharedPresentSurfaceCapabilitiesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewUsageCreateInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageCreateInfo, ImageStencilUsageCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, ImageStencilUsageCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<FormatProperties2, DrmFormatModifierPropertiesListEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassInputAttachmentAspectCreateInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BindImageMemoryInfo, BindImagePlaneMemoryInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageMemoryRequirementsInfo2, ImagePlaneMemoryRequirementsInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<QueueFamilyProperties2, QueueFamilyCheckpointPropertiesNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageMemoryBarrier, SampleLocationsInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<RenderPassBeginInfo, RenderPassSampleLocationsBeginInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineSampleLocationsStateCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSampleLocationsPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<InstanceCreateInfo, DebugReportCallbackCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationStateRasterizationOrderAMD>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageCreateInfo, ExternalMemoryImageCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryAllocateInfoNV>{ enum { value = true }; };
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryWin32HandleInfoNV>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  template <> struct isStructureChainValid<InstanceCreateInfo, ValidationFlagsEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSubgroupProperties>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceExternalImageFormatInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageCreateInfo, ExternalMemoryImageCreateInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BufferCreateInfo, ExternalMemoryBufferCreateInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryAllocateInfo>{ enum { value = true }; };
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryWin32HandleInfoKHR>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryFdInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryHostPointerInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageFormatProperties2, ExternalImageFormatProperties>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SemaphoreCreateInfo, ExportSemaphoreCreateInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<FenceCreateInfo, ExportFenceCreateInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SwapchainCreateInfoKHR, SwapchainCounterCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryAllocateInfo, MemoryAllocateFlagsInfo>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PresentInfoKHR, DeviceGroupPresentInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SwapchainCreateInfoKHR, DeviceGroupSwapchainCreateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportSwizzleStateCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineDiscardRectangleStateCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePointClippingProperties>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SamplerCreateInfo, SamplerReductionModeCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineTessellationStateCreateInfo, PipelineTessellationDomainOriginStateCreateInfo>{ enum { value = true }; };
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  template <> struct isStructureChainValid<AndroidHardwareBufferPropertiesANDROID, AndroidHardwareBufferFormatPropertiesANDROID>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceTransformFeedbackFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceTransformFeedbackFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceTransformFeedbackPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceVariablePointerFeatures>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceVariablePointerFeatures>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceVertexAttributeDivisorFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceVertexAttributeDivisorFeaturesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceVertexAttributeDivisorPropertiesEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceVulkanMemoryModelFeaturesKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceVulkanMemoryModelFeaturesKHR>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineColorBlendStateCreateInfo, PipelineColorBlendAdvancedStateCreateInfoEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageModulationStateCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceQueueCreateInfo, DeviceQueueGlobalPriorityCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<InstanceCreateInfo, DebugUtilsMessengerCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageToColorStateCreateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineDiscardRectangleStateCreateInfoEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationConservativeStateCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DescriptorSetLayoutCreateInfo, DescriptorSetLayoutBindingFlagsCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceDriverPropertiesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportShadingRateImageStateCreateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationStateRasterizationOrderAMD>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationStateStreamCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineRepresentativeFragmentTestStateCreateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineSampleLocationsStateCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineTessellationStateCreateInfo, PipelineTessellationDomainOriginStateCreateInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineVertexInputStateCreateInfo, PipelineVertexInputDivisorStateCreateInfoEXT>{ enum { value = true }; };
   template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportCoarseSampleOrderStateCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, DeviceMemoryOverallocationCreateInfoAMD>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, DeviceGroupDeviceCreateInfo>{ enum { value = true }; };
-  VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineDepthStencilStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineDepthStencilStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineMultisampleStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineMultisampleStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineTessellationStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineTessellationStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineInputAssemblyStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineInputAssemblyStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineVertexInputStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineVertexInputStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineShaderStageCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineShaderStageCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(InstanceCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(InstanceCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(EventCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(EventCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryMapFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryMapFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagsKHR)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagsKHR)
-  {
-    return "{}";
-  }
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagsKHR)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-  VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagBitsNN)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-  VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagsNN)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagsKHR)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
+  template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportExclusiveScissorStateCreateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportShadingRateImageStateCreateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportSwizzleStateCreateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportWScalingStateCreateInfoNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PresentInfoKHR, PresentRegionsKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<PresentInfoKHR, PresentTimesInfoGOOGLE>{ enum { value = true }; };
+  template <> struct isStructureChainValid<SubmitInfo, ProtectedSubmitInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<QueueFamilyProperties2, QueueFamilyCheckpointPropertiesNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassFragmentDensityMapCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassInputAttachmentAspectCreateInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassMultiviewCreateInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<RenderPassBeginInfo, RenderPassSampleLocationsBeginInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageMemoryBarrier, SampleLocationsInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<SamplerCreateInfo, SamplerReductionModeCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageFormatProperties2, SamplerYcbcrConversionImageFormatProperties>{ enum { value = true }; };
+  template <> struct isStructureChainValid<SamplerCreateInfo, SamplerYcbcrConversionInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageViewCreateInfo, SamplerYcbcrConversionInfo>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ShaderModuleCreateInfo, ShaderModuleValidationCacheCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SharedPresentSurfaceCapabilitiesKHR>{ enum { value = true }; };
+  template <> struct isStructureChainValid<SwapchainCreateInfoKHR, SwapchainCounterCreateInfoEXT>{ enum { value = true }; };
+  template <> struct isStructureChainValid<ImageFormatProperties2, TextureLODGatherFormatPropertiesAMD>{ enum { value = true }; };
+  template <> struct isStructureChainValid<InstanceCreateInfo, ValidationFlagsEXT>{ enum { value = true }; };
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
+  template <> struct isStructureChainValid<SubmitInfo, Win32KeyedMutexAcquireReleaseInfoKHR>{ enum { value = true }; };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-  VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagsKHR)
-  {
-    return "{}";
-  }
+  template <> struct isStructureChainValid<SubmitInfo, Win32KeyedMutexAcquireReleaseInfoNV>{ enum { value = true }; };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagsKHR)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagsKHR)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-  VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagBitsMVK)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-  VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagsMVK)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-  VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagBitsMVK)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-  VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagsMVK)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_FUCHSIA
-  VULKAN_HPP_INLINE std::string to_string(ImagePipeSurfaceCreateFlagBitsFUCHSIA)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#ifdef VK_USE_PLATFORM_FUCHSIA
-  VULKAN_HPP_INLINE std::string to_string(ImagePipeSurfaceCreateFlagsFUCHSIA)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-  VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineViewportSwizzleStateCreateFlagBitsNV)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineViewportSwizzleStateCreateFlagsNV)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineDiscardRectangleStateCreateFlagBitsEXT)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineDiscardRectangleStateCreateFlagsEXT)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCoverageToColorStateCreateFlagBitsNV)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCoverageToColorStateCreateFlagsNV)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCoverageModulationStateCreateFlagBitsNV)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCoverageModulationStateCreateFlagsNV)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagBitsEXT)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagsEXT)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCreateFlagBitsEXT)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCreateFlagsEXT)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCallbackDataFlagBitsEXT)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessengerCallbackDataFlagsEXT)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationConservativeStateCreateFlagBitsEXT)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationConservativeStateCreateFlagsEXT)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateStreamCreateFlagBitsEXT)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateStreamCreateFlagsEXT)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageLayout value)
-  {
-    switch (value)
-    {
-    case ImageLayout::eUndefined: return "Undefined";
-    case ImageLayout::eGeneral: return "General";
-    case ImageLayout::eColorAttachmentOptimal: return "ColorAttachmentOptimal";
-    case ImageLayout::eDepthStencilAttachmentOptimal: return "DepthStencilAttachmentOptimal";
-    case ImageLayout::eDepthStencilReadOnlyOptimal: return "DepthStencilReadOnlyOptimal";
-    case ImageLayout::eShaderReadOnlyOptimal: return "ShaderReadOnlyOptimal";
-    case ImageLayout::eTransferSrcOptimal: return "TransferSrcOptimal";
-    case ImageLayout::eTransferDstOptimal: return "TransferDstOptimal";
-    case ImageLayout::ePreinitialized: return "Preinitialized";
-    case ImageLayout::eDepthReadOnlyStencilAttachmentOptimal: return "DepthReadOnlyStencilAttachmentOptimal";
-    case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal: return "DepthAttachmentStencilReadOnlyOptimal";
-    case ImageLayout::ePresentSrcKHR: return "PresentSrcKHR";
-    case ImageLayout::eSharedPresentKHR: return "SharedPresentKHR";
-    case ImageLayout::eShadingRateOptimalNV: return "ShadingRateOptimalNV";
-    case ImageLayout::eFragmentDensityMapOptimalEXT: return "FragmentDensityMapOptimalEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AttachmentLoadOp value)
-  {
-    switch (value)
-    {
-    case AttachmentLoadOp::eLoad: return "Load";
-    case AttachmentLoadOp::eClear: return "Clear";
-    case AttachmentLoadOp::eDontCare: return "DontCare";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AttachmentStoreOp value)
-  {
-    switch (value)
-    {
-    case AttachmentStoreOp::eStore: return "Store";
-    case AttachmentStoreOp::eDontCare: return "DontCare";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageType value)
-  {
-    switch (value)
-    {
-    case ImageType::e1D: return "1D";
-    case ImageType::e2D: return "2D";
-    case ImageType::e3D: return "3D";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageTiling value)
-  {
-    switch (value)
-    {
-    case ImageTiling::eOptimal: return "Optimal";
-    case ImageTiling::eLinear: return "Linear";
-    case ImageTiling::eDrmFormatModifierEXT: return "DrmFormatModifierEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageViewType value)
-  {
-    switch (value)
-    {
-    case ImageViewType::e1D: return "1D";
-    case ImageViewType::e2D: return "2D";
-    case ImageViewType::e3D: return "3D";
-    case ImageViewType::eCube: return "Cube";
-    case ImageViewType::e1DArray: return "1DArray";
-    case ImageViewType::e2DArray: return "2DArray";
-    case ImageViewType::eCubeArray: return "CubeArray";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandBufferLevel value)
-  {
-    switch (value)
-    {
-    case CommandBufferLevel::ePrimary: return "Primary";
-    case CommandBufferLevel::eSecondary: return "Secondary";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ComponentSwizzle value)
-  {
-    switch (value)
-    {
-    case ComponentSwizzle::eIdentity: return "Identity";
-    case ComponentSwizzle::eZero: return "Zero";
-    case ComponentSwizzle::eOne: return "One";
-    case ComponentSwizzle::eR: return "R";
-    case ComponentSwizzle::eG: return "G";
-    case ComponentSwizzle::eB: return "B";
-    case ComponentSwizzle::eA: return "A";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorType value)
-  {
-    switch (value)
-    {
-    case DescriptorType::eSampler: return "Sampler";
-    case DescriptorType::eCombinedImageSampler: return "CombinedImageSampler";
-    case DescriptorType::eSampledImage: return "SampledImage";
-    case DescriptorType::eStorageImage: return "StorageImage";
-    case DescriptorType::eUniformTexelBuffer: return "UniformTexelBuffer";
-    case DescriptorType::eStorageTexelBuffer: return "StorageTexelBuffer";
-    case DescriptorType::eUniformBuffer: return "UniformBuffer";
-    case DescriptorType::eStorageBuffer: return "StorageBuffer";
-    case DescriptorType::eUniformBufferDynamic: return "UniformBufferDynamic";
-    case DescriptorType::eStorageBufferDynamic: return "StorageBufferDynamic";
-    case DescriptorType::eInputAttachment: return "InputAttachment";
-    case DescriptorType::eInlineUniformBlockEXT: return "InlineUniformBlockEXT";
-    case DescriptorType::eAccelerationStructureNV: return "AccelerationStructureNV";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryType value)
-  {
-    switch (value)
-    {
-    case QueryType::eOcclusion: return "Occlusion";
-    case QueryType::ePipelineStatistics: return "PipelineStatistics";
-    case QueryType::eTimestamp: return "Timestamp";
-    case QueryType::eTransformFeedbackStreamEXT: return "TransformFeedbackStreamEXT";
-    case QueryType::eAccelerationStructureCompactedSizeNV: return "AccelerationStructureCompactedSizeNV";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BorderColor value)
-  {
-    switch (value)
-    {
-    case BorderColor::eFloatTransparentBlack: return "FloatTransparentBlack";
-    case BorderColor::eIntTransparentBlack: return "IntTransparentBlack";
-    case BorderColor::eFloatOpaqueBlack: return "FloatOpaqueBlack";
-    case BorderColor::eIntOpaqueBlack: return "IntOpaqueBlack";
-    case BorderColor::eFloatOpaqueWhite: return "FloatOpaqueWhite";
-    case BorderColor::eIntOpaqueWhite: return "IntOpaqueWhite";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineBindPoint value)
-  {
-    switch (value)
-    {
-    case PipelineBindPoint::eGraphics: return "Graphics";
-    case PipelineBindPoint::eCompute: return "Compute";
-    case PipelineBindPoint::eRayTracingNV: return "RayTracingNV";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCacheHeaderVersion value)
-  {
-    switch (value)
-    {
-    case PipelineCacheHeaderVersion::eOne: return "One";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PrimitiveTopology value)
-  {
-    switch (value)
-    {
-    case PrimitiveTopology::ePointList: return "PointList";
-    case PrimitiveTopology::eLineList: return "LineList";
-    case PrimitiveTopology::eLineStrip: return "LineStrip";
-    case PrimitiveTopology::eTriangleList: return "TriangleList";
-    case PrimitiveTopology::eTriangleStrip: return "TriangleStrip";
-    case PrimitiveTopology::eTriangleFan: return "TriangleFan";
-    case PrimitiveTopology::eLineListWithAdjacency: return "LineListWithAdjacency";
-    case PrimitiveTopology::eLineStripWithAdjacency: return "LineStripWithAdjacency";
-    case PrimitiveTopology::eTriangleListWithAdjacency: return "TriangleListWithAdjacency";
-    case PrimitiveTopology::eTriangleStripWithAdjacency: return "TriangleStripWithAdjacency";
-    case PrimitiveTopology::ePatchList: return "PatchList";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SharingMode value)
-  {
-    switch (value)
-    {
-    case SharingMode::eExclusive: return "Exclusive";
-    case SharingMode::eConcurrent: return "Concurrent";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(IndexType value)
-  {
-    switch (value)
-    {
-    case IndexType::eUint16: return "Uint16";
-    case IndexType::eUint32: return "Uint32";
-    case IndexType::eNoneNV: return "NoneNV";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(Filter value)
-  {
-    switch (value)
-    {
-    case Filter::eNearest: return "Nearest";
-    case Filter::eLinear: return "Linear";
-    case Filter::eCubicIMG: return "CubicIMG";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerMipmapMode value)
-  {
-    switch (value)
-    {
-    case SamplerMipmapMode::eNearest: return "Nearest";
-    case SamplerMipmapMode::eLinear: return "Linear";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerAddressMode value)
-  {
-    switch (value)
-    {
-    case SamplerAddressMode::eRepeat: return "Repeat";
-    case SamplerAddressMode::eMirroredRepeat: return "MirroredRepeat";
-    case SamplerAddressMode::eClampToEdge: return "ClampToEdge";
-    case SamplerAddressMode::eClampToBorder: return "ClampToBorder";
-    case SamplerAddressMode::eMirrorClampToEdge: return "MirrorClampToEdge";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CompareOp value)
-  {
-    switch (value)
-    {
-    case CompareOp::eNever: return "Never";
-    case CompareOp::eLess: return "Less";
-    case CompareOp::eEqual: return "Equal";
-    case CompareOp::eLessOrEqual: return "LessOrEqual";
-    case CompareOp::eGreater: return "Greater";
-    case CompareOp::eNotEqual: return "NotEqual";
-    case CompareOp::eGreaterOrEqual: return "GreaterOrEqual";
-    case CompareOp::eAlways: return "Always";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PolygonMode value)
-  {
-    switch (value)
-    {
-    case PolygonMode::eFill: return "Fill";
-    case PolygonMode::eLine: return "Line";
-    case PolygonMode::ePoint: return "Point";
-    case PolygonMode::eFillRectangleNV: return "FillRectangleNV";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CullModeFlagBits value)
-  {
-    switch (value)
-    {
-    case CullModeFlagBits::eNone: return "None";
-    case CullModeFlagBits::eFront: return "Front";
-    case CullModeFlagBits::eBack: return "Back";
-    case CullModeFlagBits::eFrontAndBack: return "FrontAndBack";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CullModeFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & CullModeFlagBits::eNone) result += "None | ";
-    if (value & CullModeFlagBits::eFront) result += "Front | ";
-    if (value & CullModeFlagBits::eBack) result += "Back | ";
-    if (value & CullModeFlagBits::eFrontAndBack) result += "FrontAndBack | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FrontFace value)
-  {
-    switch (value)
-    {
-    case FrontFace::eCounterClockwise: return "CounterClockwise";
-    case FrontFace::eClockwise: return "Clockwise";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BlendFactor value)
-  {
-    switch (value)
-    {
-    case BlendFactor::eZero: return "Zero";
-    case BlendFactor::eOne: return "One";
-    case BlendFactor::eSrcColor: return "SrcColor";
-    case BlendFactor::eOneMinusSrcColor: return "OneMinusSrcColor";
-    case BlendFactor::eDstColor: return "DstColor";
-    case BlendFactor::eOneMinusDstColor: return "OneMinusDstColor";
-    case BlendFactor::eSrcAlpha: return "SrcAlpha";
-    case BlendFactor::eOneMinusSrcAlpha: return "OneMinusSrcAlpha";
-    case BlendFactor::eDstAlpha: return "DstAlpha";
-    case BlendFactor::eOneMinusDstAlpha: return "OneMinusDstAlpha";
-    case BlendFactor::eConstantColor: return "ConstantColor";
-    case BlendFactor::eOneMinusConstantColor: return "OneMinusConstantColor";
-    case BlendFactor::eConstantAlpha: return "ConstantAlpha";
-    case BlendFactor::eOneMinusConstantAlpha: return "OneMinusConstantAlpha";
-    case BlendFactor::eSrcAlphaSaturate: return "SrcAlphaSaturate";
-    case BlendFactor::eSrc1Color: return "Src1Color";
-    case BlendFactor::eOneMinusSrc1Color: return "OneMinusSrc1Color";
-    case BlendFactor::eSrc1Alpha: return "Src1Alpha";
-    case BlendFactor::eOneMinusSrc1Alpha: return "OneMinusSrc1Alpha";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BlendOp value)
-  {
-    switch (value)
-    {
-    case BlendOp::eAdd: return "Add";
-    case BlendOp::eSubtract: return "Subtract";
-    case BlendOp::eReverseSubtract: return "ReverseSubtract";
-    case BlendOp::eMin: return "Min";
-    case BlendOp::eMax: return "Max";
-    case BlendOp::eZeroEXT: return "ZeroEXT";
-    case BlendOp::eSrcEXT: return "SrcEXT";
-    case BlendOp::eDstEXT: return "DstEXT";
-    case BlendOp::eSrcOverEXT: return "SrcOverEXT";
-    case BlendOp::eDstOverEXT: return "DstOverEXT";
-    case BlendOp::eSrcInEXT: return "SrcInEXT";
-    case BlendOp::eDstInEXT: return "DstInEXT";
-    case BlendOp::eSrcOutEXT: return "SrcOutEXT";
-    case BlendOp::eDstOutEXT: return "DstOutEXT";
-    case BlendOp::eSrcAtopEXT: return "SrcAtopEXT";
-    case BlendOp::eDstAtopEXT: return "DstAtopEXT";
-    case BlendOp::eXorEXT: return "XorEXT";
-    case BlendOp::eMultiplyEXT: return "MultiplyEXT";
-    case BlendOp::eScreenEXT: return "ScreenEXT";
-    case BlendOp::eOverlayEXT: return "OverlayEXT";
-    case BlendOp::eDarkenEXT: return "DarkenEXT";
-    case BlendOp::eLightenEXT: return "LightenEXT";
-    case BlendOp::eColordodgeEXT: return "ColordodgeEXT";
-    case BlendOp::eColorburnEXT: return "ColorburnEXT";
-    case BlendOp::eHardlightEXT: return "HardlightEXT";
-    case BlendOp::eSoftlightEXT: return "SoftlightEXT";
-    case BlendOp::eDifferenceEXT: return "DifferenceEXT";
-    case BlendOp::eExclusionEXT: return "ExclusionEXT";
-    case BlendOp::eInvertEXT: return "InvertEXT";
-    case BlendOp::eInvertRgbEXT: return "InvertRgbEXT";
-    case BlendOp::eLineardodgeEXT: return "LineardodgeEXT";
-    case BlendOp::eLinearburnEXT: return "LinearburnEXT";
-    case BlendOp::eVividlightEXT: return "VividlightEXT";
-    case BlendOp::eLinearlightEXT: return "LinearlightEXT";
-    case BlendOp::ePinlightEXT: return "PinlightEXT";
-    case BlendOp::eHardmixEXT: return "HardmixEXT";
-    case BlendOp::eHslHueEXT: return "HslHueEXT";
-    case BlendOp::eHslSaturationEXT: return "HslSaturationEXT";
-    case BlendOp::eHslColorEXT: return "HslColorEXT";
-    case BlendOp::eHslLuminosityEXT: return "HslLuminosityEXT";
-    case BlendOp::ePlusEXT: return "PlusEXT";
-    case BlendOp::ePlusClampedEXT: return "PlusClampedEXT";
-    case BlendOp::ePlusClampedAlphaEXT: return "PlusClampedAlphaEXT";
-    case BlendOp::ePlusDarkerEXT: return "PlusDarkerEXT";
-    case BlendOp::eMinusEXT: return "MinusEXT";
-    case BlendOp::eMinusClampedEXT: return "MinusClampedEXT";
-    case BlendOp::eContrastEXT: return "ContrastEXT";
-    case BlendOp::eInvertOvgEXT: return "InvertOvgEXT";
-    case BlendOp::eRedEXT: return "RedEXT";
-    case BlendOp::eGreenEXT: return "GreenEXT";
-    case BlendOp::eBlueEXT: return "BlueEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(StencilOp value)
-  {
-    switch (value)
-    {
-    case StencilOp::eKeep: return "Keep";
-    case StencilOp::eZero: return "Zero";
-    case StencilOp::eReplace: return "Replace";
-    case StencilOp::eIncrementAndClamp: return "IncrementAndClamp";
-    case StencilOp::eDecrementAndClamp: return "DecrementAndClamp";
-    case StencilOp::eInvert: return "Invert";
-    case StencilOp::eIncrementAndWrap: return "IncrementAndWrap";
-    case StencilOp::eDecrementAndWrap: return "DecrementAndWrap";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(LogicOp value)
-  {
-    switch (value)
-    {
-    case LogicOp::eClear: return "Clear";
-    case LogicOp::eAnd: return "And";
-    case LogicOp::eAndReverse: return "AndReverse";
-    case LogicOp::eCopy: return "Copy";
-    case LogicOp::eAndInverted: return "AndInverted";
-    case LogicOp::eNoOp: return "NoOp";
-    case LogicOp::eXor: return "Xor";
-    case LogicOp::eOr: return "Or";
-    case LogicOp::eNor: return "Nor";
-    case LogicOp::eEquivalent: return "Equivalent";
-    case LogicOp::eInvert: return "Invert";
-    case LogicOp::eOrReverse: return "OrReverse";
-    case LogicOp::eCopyInverted: return "CopyInverted";
-    case LogicOp::eOrInverted: return "OrInverted";
-    case LogicOp::eNand: return "Nand";
-    case LogicOp::eSet: return "Set";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(InternalAllocationType value)
-  {
-    switch (value)
-    {
-    case InternalAllocationType::eExecutable: return "Executable";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SystemAllocationScope value)
-  {
-    switch (value)
-    {
-    case SystemAllocationScope::eCommand: return "Command";
-    case SystemAllocationScope::eObject: return "Object";
-    case SystemAllocationScope::eCache: return "Cache";
-    case SystemAllocationScope::eDevice: return "Device";
-    case SystemAllocationScope::eInstance: return "Instance";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PhysicalDeviceType value)
-  {
-    switch (value)
-    {
-    case PhysicalDeviceType::eOther: return "Other";
-    case PhysicalDeviceType::eIntegratedGpu: return "IntegratedGpu";
-    case PhysicalDeviceType::eDiscreteGpu: return "DiscreteGpu";
-    case PhysicalDeviceType::eVirtualGpu: return "VirtualGpu";
-    case PhysicalDeviceType::eCpu: return "Cpu";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(VertexInputRate value)
-  {
-    switch (value)
-    {
-    case VertexInputRate::eVertex: return "Vertex";
-    case VertexInputRate::eInstance: return "Instance";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(Format value)
-  {
-    switch (value)
-    {
-    case Format::eUndefined: return "Undefined";
-    case Format::eR4G4UnormPack8: return "R4G4UnormPack8";
-    case Format::eR4G4B4A4UnormPack16: return "R4G4B4A4UnormPack16";
-    case Format::eB4G4R4A4UnormPack16: return "B4G4R4A4UnormPack16";
-    case Format::eR5G6B5UnormPack16: return "R5G6B5UnormPack16";
-    case Format::eB5G6R5UnormPack16: return "B5G6R5UnormPack16";
-    case Format::eR5G5B5A1UnormPack16: return "R5G5B5A1UnormPack16";
-    case Format::eB5G5R5A1UnormPack16: return "B5G5R5A1UnormPack16";
-    case Format::eA1R5G5B5UnormPack16: return "A1R5G5B5UnormPack16";
-    case Format::eR8Unorm: return "R8Unorm";
-    case Format::eR8Snorm: return "R8Snorm";
-    case Format::eR8Uscaled: return "R8Uscaled";
-    case Format::eR8Sscaled: return "R8Sscaled";
-    case Format::eR8Uint: return "R8Uint";
-    case Format::eR8Sint: return "R8Sint";
-    case Format::eR8Srgb: return "R8Srgb";
-    case Format::eR8G8Unorm: return "R8G8Unorm";
-    case Format::eR8G8Snorm: return "R8G8Snorm";
-    case Format::eR8G8Uscaled: return "R8G8Uscaled";
-    case Format::eR8G8Sscaled: return "R8G8Sscaled";
-    case Format::eR8G8Uint: return "R8G8Uint";
-    case Format::eR8G8Sint: return "R8G8Sint";
-    case Format::eR8G8Srgb: return "R8G8Srgb";
-    case Format::eR8G8B8Unorm: return "R8G8B8Unorm";
-    case Format::eR8G8B8Snorm: return "R8G8B8Snorm";
-    case Format::eR8G8B8Uscaled: return "R8G8B8Uscaled";
-    case Format::eR8G8B8Sscaled: return "R8G8B8Sscaled";
-    case Format::eR8G8B8Uint: return "R8G8B8Uint";
-    case Format::eR8G8B8Sint: return "R8G8B8Sint";
-    case Format::eR8G8B8Srgb: return "R8G8B8Srgb";
-    case Format::eB8G8R8Unorm: return "B8G8R8Unorm";
-    case Format::eB8G8R8Snorm: return "B8G8R8Snorm";
-    case Format::eB8G8R8Uscaled: return "B8G8R8Uscaled";
-    case Format::eB8G8R8Sscaled: return "B8G8R8Sscaled";
-    case Format::eB8G8R8Uint: return "B8G8R8Uint";
-    case Format::eB8G8R8Sint: return "B8G8R8Sint";
-    case Format::eB8G8R8Srgb: return "B8G8R8Srgb";
-    case Format::eR8G8B8A8Unorm: return "R8G8B8A8Unorm";
-    case Format::eR8G8B8A8Snorm: return "R8G8B8A8Snorm";
-    case Format::eR8G8B8A8Uscaled: return "R8G8B8A8Uscaled";
-    case Format::eR8G8B8A8Sscaled: return "R8G8B8A8Sscaled";
-    case Format::eR8G8B8A8Uint: return "R8G8B8A8Uint";
-    case Format::eR8G8B8A8Sint: return "R8G8B8A8Sint";
-    case Format::eR8G8B8A8Srgb: return "R8G8B8A8Srgb";
-    case Format::eB8G8R8A8Unorm: return "B8G8R8A8Unorm";
-    case Format::eB8G8R8A8Snorm: return "B8G8R8A8Snorm";
-    case Format::eB8G8R8A8Uscaled: return "B8G8R8A8Uscaled";
-    case Format::eB8G8R8A8Sscaled: return "B8G8R8A8Sscaled";
-    case Format::eB8G8R8A8Uint: return "B8G8R8A8Uint";
-    case Format::eB8G8R8A8Sint: return "B8G8R8A8Sint";
-    case Format::eB8G8R8A8Srgb: return "B8G8R8A8Srgb";
-    case Format::eA8B8G8R8UnormPack32: return "A8B8G8R8UnormPack32";
-    case Format::eA8B8G8R8SnormPack32: return "A8B8G8R8SnormPack32";
-    case Format::eA8B8G8R8UscaledPack32: return "A8B8G8R8UscaledPack32";
-    case Format::eA8B8G8R8SscaledPack32: return "A8B8G8R8SscaledPack32";
-    case Format::eA8B8G8R8UintPack32: return "A8B8G8R8UintPack32";
-    case Format::eA8B8G8R8SintPack32: return "A8B8G8R8SintPack32";
-    case Format::eA8B8G8R8SrgbPack32: return "A8B8G8R8SrgbPack32";
-    case Format::eA2R10G10B10UnormPack32: return "A2R10G10B10UnormPack32";
-    case Format::eA2R10G10B10SnormPack32: return "A2R10G10B10SnormPack32";
-    case Format::eA2R10G10B10UscaledPack32: return "A2R10G10B10UscaledPack32";
-    case Format::eA2R10G10B10SscaledPack32: return "A2R10G10B10SscaledPack32";
-    case Format::eA2R10G10B10UintPack32: return "A2R10G10B10UintPack32";
-    case Format::eA2R10G10B10SintPack32: return "A2R10G10B10SintPack32";
-    case Format::eA2B10G10R10UnormPack32: return "A2B10G10R10UnormPack32";
-    case Format::eA2B10G10R10SnormPack32: return "A2B10G10R10SnormPack32";
-    case Format::eA2B10G10R10UscaledPack32: return "A2B10G10R10UscaledPack32";
-    case Format::eA2B10G10R10SscaledPack32: return "A2B10G10R10SscaledPack32";
-    case Format::eA2B10G10R10UintPack32: return "A2B10G10R10UintPack32";
-    case Format::eA2B10G10R10SintPack32: return "A2B10G10R10SintPack32";
-    case Format::eR16Unorm: return "R16Unorm";
-    case Format::eR16Snorm: return "R16Snorm";
-    case Format::eR16Uscaled: return "R16Uscaled";
-    case Format::eR16Sscaled: return "R16Sscaled";
-    case Format::eR16Uint: return "R16Uint";
-    case Format::eR16Sint: return "R16Sint";
-    case Format::eR16Sfloat: return "R16Sfloat";
-    case Format::eR16G16Unorm: return "R16G16Unorm";
-    case Format::eR16G16Snorm: return "R16G16Snorm";
-    case Format::eR16G16Uscaled: return "R16G16Uscaled";
-    case Format::eR16G16Sscaled: return "R16G16Sscaled";
-    case Format::eR16G16Uint: return "R16G16Uint";
-    case Format::eR16G16Sint: return "R16G16Sint";
-    case Format::eR16G16Sfloat: return "R16G16Sfloat";
-    case Format::eR16G16B16Unorm: return "R16G16B16Unorm";
-    case Format::eR16G16B16Snorm: return "R16G16B16Snorm";
-    case Format::eR16G16B16Uscaled: return "R16G16B16Uscaled";
-    case Format::eR16G16B16Sscaled: return "R16G16B16Sscaled";
-    case Format::eR16G16B16Uint: return "R16G16B16Uint";
-    case Format::eR16G16B16Sint: return "R16G16B16Sint";
-    case Format::eR16G16B16Sfloat: return "R16G16B16Sfloat";
-    case Format::eR16G16B16A16Unorm: return "R16G16B16A16Unorm";
-    case Format::eR16G16B16A16Snorm: return "R16G16B16A16Snorm";
-    case Format::eR16G16B16A16Uscaled: return "R16G16B16A16Uscaled";
-    case Format::eR16G16B16A16Sscaled: return "R16G16B16A16Sscaled";
-    case Format::eR16G16B16A16Uint: return "R16G16B16A16Uint";
-    case Format::eR16G16B16A16Sint: return "R16G16B16A16Sint";
-    case Format::eR16G16B16A16Sfloat: return "R16G16B16A16Sfloat";
-    case Format::eR32Uint: return "R32Uint";
-    case Format::eR32Sint: return "R32Sint";
-    case Format::eR32Sfloat: return "R32Sfloat";
-    case Format::eR32G32Uint: return "R32G32Uint";
-    case Format::eR32G32Sint: return "R32G32Sint";
-    case Format::eR32G32Sfloat: return "R32G32Sfloat";
-    case Format::eR32G32B32Uint: return "R32G32B32Uint";
-    case Format::eR32G32B32Sint: return "R32G32B32Sint";
-    case Format::eR32G32B32Sfloat: return "R32G32B32Sfloat";
-    case Format::eR32G32B32A32Uint: return "R32G32B32A32Uint";
-    case Format::eR32G32B32A32Sint: return "R32G32B32A32Sint";
-    case Format::eR32G32B32A32Sfloat: return "R32G32B32A32Sfloat";
-    case Format::eR64Uint: return "R64Uint";
-    case Format::eR64Sint: return "R64Sint";
-    case Format::eR64Sfloat: return "R64Sfloat";
-    case Format::eR64G64Uint: return "R64G64Uint";
-    case Format::eR64G64Sint: return "R64G64Sint";
-    case Format::eR64G64Sfloat: return "R64G64Sfloat";
-    case Format::eR64G64B64Uint: return "R64G64B64Uint";
-    case Format::eR64G64B64Sint: return "R64G64B64Sint";
-    case Format::eR64G64B64Sfloat: return "R64G64B64Sfloat";
-    case Format::eR64G64B64A64Uint: return "R64G64B64A64Uint";
-    case Format::eR64G64B64A64Sint: return "R64G64B64A64Sint";
-    case Format::eR64G64B64A64Sfloat: return "R64G64B64A64Sfloat";
-    case Format::eB10G11R11UfloatPack32: return "B10G11R11UfloatPack32";
-    case Format::eE5B9G9R9UfloatPack32: return "E5B9G9R9UfloatPack32";
-    case Format::eD16Unorm: return "D16Unorm";
-    case Format::eX8D24UnormPack32: return "X8D24UnormPack32";
-    case Format::eD32Sfloat: return "D32Sfloat";
-    case Format::eS8Uint: return "S8Uint";
-    case Format::eD16UnormS8Uint: return "D16UnormS8Uint";
-    case Format::eD24UnormS8Uint: return "D24UnormS8Uint";
-    case Format::eD32SfloatS8Uint: return "D32SfloatS8Uint";
-    case Format::eBc1RgbUnormBlock: return "Bc1RgbUnormBlock";
-    case Format::eBc1RgbSrgbBlock: return "Bc1RgbSrgbBlock";
-    case Format::eBc1RgbaUnormBlock: return "Bc1RgbaUnormBlock";
-    case Format::eBc1RgbaSrgbBlock: return "Bc1RgbaSrgbBlock";
-    case Format::eBc2UnormBlock: return "Bc2UnormBlock";
-    case Format::eBc2SrgbBlock: return "Bc2SrgbBlock";
-    case Format::eBc3UnormBlock: return "Bc3UnormBlock";
-    case Format::eBc3SrgbBlock: return "Bc3SrgbBlock";
-    case Format::eBc4UnormBlock: return "Bc4UnormBlock";
-    case Format::eBc4SnormBlock: return "Bc4SnormBlock";
-    case Format::eBc5UnormBlock: return "Bc5UnormBlock";
-    case Format::eBc5SnormBlock: return "Bc5SnormBlock";
-    case Format::eBc6HUfloatBlock: return "Bc6HUfloatBlock";
-    case Format::eBc6HSfloatBlock: return "Bc6HSfloatBlock";
-    case Format::eBc7UnormBlock: return "Bc7UnormBlock";
-    case Format::eBc7SrgbBlock: return "Bc7SrgbBlock";
-    case Format::eEtc2R8G8B8UnormBlock: return "Etc2R8G8B8UnormBlock";
-    case Format::eEtc2R8G8B8SrgbBlock: return "Etc2R8G8B8SrgbBlock";
-    case Format::eEtc2R8G8B8A1UnormBlock: return "Etc2R8G8B8A1UnormBlock";
-    case Format::eEtc2R8G8B8A1SrgbBlock: return "Etc2R8G8B8A1SrgbBlock";
-    case Format::eEtc2R8G8B8A8UnormBlock: return "Etc2R8G8B8A8UnormBlock";
-    case Format::eEtc2R8G8B8A8SrgbBlock: return "Etc2R8G8B8A8SrgbBlock";
-    case Format::eEacR11UnormBlock: return "EacR11UnormBlock";
-    case Format::eEacR11SnormBlock: return "EacR11SnormBlock";
-    case Format::eEacR11G11UnormBlock: return "EacR11G11UnormBlock";
-    case Format::eEacR11G11SnormBlock: return "EacR11G11SnormBlock";
-    case Format::eAstc4x4UnormBlock: return "Astc4x4UnormBlock";
-    case Format::eAstc4x4SrgbBlock: return "Astc4x4SrgbBlock";
-    case Format::eAstc5x4UnormBlock: return "Astc5x4UnormBlock";
-    case Format::eAstc5x4SrgbBlock: return "Astc5x4SrgbBlock";
-    case Format::eAstc5x5UnormBlock: return "Astc5x5UnormBlock";
-    case Format::eAstc5x5SrgbBlock: return "Astc5x5SrgbBlock";
-    case Format::eAstc6x5UnormBlock: return "Astc6x5UnormBlock";
-    case Format::eAstc6x5SrgbBlock: return "Astc6x5SrgbBlock";
-    case Format::eAstc6x6UnormBlock: return "Astc6x6UnormBlock";
-    case Format::eAstc6x6SrgbBlock: return "Astc6x6SrgbBlock";
-    case Format::eAstc8x5UnormBlock: return "Astc8x5UnormBlock";
-    case Format::eAstc8x5SrgbBlock: return "Astc8x5SrgbBlock";
-    case Format::eAstc8x6UnormBlock: return "Astc8x6UnormBlock";
-    case Format::eAstc8x6SrgbBlock: return "Astc8x6SrgbBlock";
-    case Format::eAstc8x8UnormBlock: return "Astc8x8UnormBlock";
-    case Format::eAstc8x8SrgbBlock: return "Astc8x8SrgbBlock";
-    case Format::eAstc10x5UnormBlock: return "Astc10x5UnormBlock";
-    case Format::eAstc10x5SrgbBlock: return "Astc10x5SrgbBlock";
-    case Format::eAstc10x6UnormBlock: return "Astc10x6UnormBlock";
-    case Format::eAstc10x6SrgbBlock: return "Astc10x6SrgbBlock";
-    case Format::eAstc10x8UnormBlock: return "Astc10x8UnormBlock";
-    case Format::eAstc10x8SrgbBlock: return "Astc10x8SrgbBlock";
-    case Format::eAstc10x10UnormBlock: return "Astc10x10UnormBlock";
-    case Format::eAstc10x10SrgbBlock: return "Astc10x10SrgbBlock";
-    case Format::eAstc12x10UnormBlock: return "Astc12x10UnormBlock";
-    case Format::eAstc12x10SrgbBlock: return "Astc12x10SrgbBlock";
-    case Format::eAstc12x12UnormBlock: return "Astc12x12UnormBlock";
-    case Format::eAstc12x12SrgbBlock: return "Astc12x12SrgbBlock";
-    case Format::eG8B8G8R8422Unorm: return "G8B8G8R8422Unorm";
-    case Format::eB8G8R8G8422Unorm: return "B8G8R8G8422Unorm";
-    case Format::eG8B8R83Plane420Unorm: return "G8B8R83Plane420Unorm";
-    case Format::eG8B8R82Plane420Unorm: return "G8B8R82Plane420Unorm";
-    case Format::eG8B8R83Plane422Unorm: return "G8B8R83Plane422Unorm";
-    case Format::eG8B8R82Plane422Unorm: return "G8B8R82Plane422Unorm";
-    case Format::eG8B8R83Plane444Unorm: return "G8B8R83Plane444Unorm";
-    case Format::eR10X6UnormPack16: return "R10X6UnormPack16";
-    case Format::eR10X6G10X6Unorm2Pack16: return "R10X6G10X6Unorm2Pack16";
-    case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: return "R10X6G10X6B10X6A10X6Unorm4Pack16";
-    case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: return "G10X6B10X6G10X6R10X6422Unorm4Pack16";
-    case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: return "B10X6G10X6R10X6G10X6422Unorm4Pack16";
-    case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: return "G10X6B10X6R10X63Plane420Unorm3Pack16";
-    case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: return "G10X6B10X6R10X62Plane420Unorm3Pack16";
-    case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: return "G10X6B10X6R10X63Plane422Unorm3Pack16";
-    case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: return "G10X6B10X6R10X62Plane422Unorm3Pack16";
-    case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: return "G10X6B10X6R10X63Plane444Unorm3Pack16";
-    case Format::eR12X4UnormPack16: return "R12X4UnormPack16";
-    case Format::eR12X4G12X4Unorm2Pack16: return "R12X4G12X4Unorm2Pack16";
-    case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: return "R12X4G12X4B12X4A12X4Unorm4Pack16";
-    case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: return "G12X4B12X4G12X4R12X4422Unorm4Pack16";
-    case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: return "B12X4G12X4R12X4G12X4422Unorm4Pack16";
-    case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: return "G12X4B12X4R12X43Plane420Unorm3Pack16";
-    case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: return "G12X4B12X4R12X42Plane420Unorm3Pack16";
-    case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: return "G12X4B12X4R12X43Plane422Unorm3Pack16";
-    case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: return "G12X4B12X4R12X42Plane422Unorm3Pack16";
-    case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: return "G12X4B12X4R12X43Plane444Unorm3Pack16";
-    case Format::eG16B16G16R16422Unorm: return "G16B16G16R16422Unorm";
-    case Format::eB16G16R16G16422Unorm: return "B16G16R16G16422Unorm";
-    case Format::eG16B16R163Plane420Unorm: return "G16B16R163Plane420Unorm";
-    case Format::eG16B16R162Plane420Unorm: return "G16B16R162Plane420Unorm";
-    case Format::eG16B16R163Plane422Unorm: return "G16B16R163Plane422Unorm";
-    case Format::eG16B16R162Plane422Unorm: return "G16B16R162Plane422Unorm";
-    case Format::eG16B16R163Plane444Unorm: return "G16B16R163Plane444Unorm";
-    case Format::ePvrtc12BppUnormBlockIMG: return "Pvrtc12BppUnormBlockIMG";
-    case Format::ePvrtc14BppUnormBlockIMG: return "Pvrtc14BppUnormBlockIMG";
-    case Format::ePvrtc22BppUnormBlockIMG: return "Pvrtc22BppUnormBlockIMG";
-    case Format::ePvrtc24BppUnormBlockIMG: return "Pvrtc24BppUnormBlockIMG";
-    case Format::ePvrtc12BppSrgbBlockIMG: return "Pvrtc12BppSrgbBlockIMG";
-    case Format::ePvrtc14BppSrgbBlockIMG: return "Pvrtc14BppSrgbBlockIMG";
-    case Format::ePvrtc22BppSrgbBlockIMG: return "Pvrtc22BppSrgbBlockIMG";
-    case Format::ePvrtc24BppSrgbBlockIMG: return "Pvrtc24BppSrgbBlockIMG";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(StructureType value)
-  {
-    switch (value)
-    {
-    case StructureType::eApplicationInfo: return "ApplicationInfo";
-    case StructureType::eInstanceCreateInfo: return "InstanceCreateInfo";
-    case StructureType::eDeviceQueueCreateInfo: return "DeviceQueueCreateInfo";
-    case StructureType::eDeviceCreateInfo: return "DeviceCreateInfo";
-    case StructureType::eSubmitInfo: return "SubmitInfo";
-    case StructureType::eMemoryAllocateInfo: return "MemoryAllocateInfo";
-    case StructureType::eMappedMemoryRange: return "MappedMemoryRange";
-    case StructureType::eBindSparseInfo: return "BindSparseInfo";
-    case StructureType::eFenceCreateInfo: return "FenceCreateInfo";
-    case StructureType::eSemaphoreCreateInfo: return "SemaphoreCreateInfo";
-    case StructureType::eEventCreateInfo: return "EventCreateInfo";
-    case StructureType::eQueryPoolCreateInfo: return "QueryPoolCreateInfo";
-    case StructureType::eBufferCreateInfo: return "BufferCreateInfo";
-    case StructureType::eBufferViewCreateInfo: return "BufferViewCreateInfo";
-    case StructureType::eImageCreateInfo: return "ImageCreateInfo";
-    case StructureType::eImageViewCreateInfo: return "ImageViewCreateInfo";
-    case StructureType::eShaderModuleCreateInfo: return "ShaderModuleCreateInfo";
-    case StructureType::ePipelineCacheCreateInfo: return "PipelineCacheCreateInfo";
-    case StructureType::ePipelineShaderStageCreateInfo: return "PipelineShaderStageCreateInfo";
-    case StructureType::ePipelineVertexInputStateCreateInfo: return "PipelineVertexInputStateCreateInfo";
-    case StructureType::ePipelineInputAssemblyStateCreateInfo: return "PipelineInputAssemblyStateCreateInfo";
-    case StructureType::ePipelineTessellationStateCreateInfo: return "PipelineTessellationStateCreateInfo";
-    case StructureType::ePipelineViewportStateCreateInfo: return "PipelineViewportStateCreateInfo";
-    case StructureType::ePipelineRasterizationStateCreateInfo: return "PipelineRasterizationStateCreateInfo";
-    case StructureType::ePipelineMultisampleStateCreateInfo: return "PipelineMultisampleStateCreateInfo";
-    case StructureType::ePipelineDepthStencilStateCreateInfo: return "PipelineDepthStencilStateCreateInfo";
-    case StructureType::ePipelineColorBlendStateCreateInfo: return "PipelineColorBlendStateCreateInfo";
-    case StructureType::ePipelineDynamicStateCreateInfo: return "PipelineDynamicStateCreateInfo";
-    case StructureType::eGraphicsPipelineCreateInfo: return "GraphicsPipelineCreateInfo";
-    case StructureType::eComputePipelineCreateInfo: return "ComputePipelineCreateInfo";
-    case StructureType::ePipelineLayoutCreateInfo: return "PipelineLayoutCreateInfo";
-    case StructureType::eSamplerCreateInfo: return "SamplerCreateInfo";
-    case StructureType::eDescriptorSetLayoutCreateInfo: return "DescriptorSetLayoutCreateInfo";
-    case StructureType::eDescriptorPoolCreateInfo: return "DescriptorPoolCreateInfo";
-    case StructureType::eDescriptorSetAllocateInfo: return "DescriptorSetAllocateInfo";
-    case StructureType::eWriteDescriptorSet: return "WriteDescriptorSet";
-    case StructureType::eCopyDescriptorSet: return "CopyDescriptorSet";
-    case StructureType::eFramebufferCreateInfo: return "FramebufferCreateInfo";
-    case StructureType::eRenderPassCreateInfo: return "RenderPassCreateInfo";
-    case StructureType::eCommandPoolCreateInfo: return "CommandPoolCreateInfo";
-    case StructureType::eCommandBufferAllocateInfo: return "CommandBufferAllocateInfo";
-    case StructureType::eCommandBufferInheritanceInfo: return "CommandBufferInheritanceInfo";
-    case StructureType::eCommandBufferBeginInfo: return "CommandBufferBeginInfo";
-    case StructureType::eRenderPassBeginInfo: return "RenderPassBeginInfo";
-    case StructureType::eBufferMemoryBarrier: return "BufferMemoryBarrier";
-    case StructureType::eImageMemoryBarrier: return "ImageMemoryBarrier";
-    case StructureType::eMemoryBarrier: return "MemoryBarrier";
-    case StructureType::eLoaderInstanceCreateInfo: return "LoaderInstanceCreateInfo";
-    case StructureType::eLoaderDeviceCreateInfo: return "LoaderDeviceCreateInfo";
-    case StructureType::ePhysicalDeviceSubgroupProperties: return "PhysicalDeviceSubgroupProperties";
-    case StructureType::eBindBufferMemoryInfo: return "BindBufferMemoryInfo";
-    case StructureType::eBindImageMemoryInfo: return "BindImageMemoryInfo";
-    case StructureType::ePhysicalDevice16BitStorageFeatures: return "PhysicalDevice16BitStorageFeatures";
-    case StructureType::eMemoryDedicatedRequirements: return "MemoryDedicatedRequirements";
-    case StructureType::eMemoryDedicatedAllocateInfo: return "MemoryDedicatedAllocateInfo";
-    case StructureType::eMemoryAllocateFlagsInfo: return "MemoryAllocateFlagsInfo";
-    case StructureType::eDeviceGroupRenderPassBeginInfo: return "DeviceGroupRenderPassBeginInfo";
-    case StructureType::eDeviceGroupCommandBufferBeginInfo: return "DeviceGroupCommandBufferBeginInfo";
-    case StructureType::eDeviceGroupSubmitInfo: return "DeviceGroupSubmitInfo";
-    case StructureType::eDeviceGroupBindSparseInfo: return "DeviceGroupBindSparseInfo";
-    case StructureType::eBindBufferMemoryDeviceGroupInfo: return "BindBufferMemoryDeviceGroupInfo";
-    case StructureType::eBindImageMemoryDeviceGroupInfo: return "BindImageMemoryDeviceGroupInfo";
-    case StructureType::ePhysicalDeviceGroupProperties: return "PhysicalDeviceGroupProperties";
-    case StructureType::eDeviceGroupDeviceCreateInfo: return "DeviceGroupDeviceCreateInfo";
-    case StructureType::eBufferMemoryRequirementsInfo2: return "BufferMemoryRequirementsInfo2";
-    case StructureType::eImageMemoryRequirementsInfo2: return "ImageMemoryRequirementsInfo2";
-    case StructureType::eImageSparseMemoryRequirementsInfo2: return "ImageSparseMemoryRequirementsInfo2";
-    case StructureType::eMemoryRequirements2: return "MemoryRequirements2";
-    case StructureType::eSparseImageMemoryRequirements2: return "SparseImageMemoryRequirements2";
-    case StructureType::ePhysicalDeviceFeatures2: return "PhysicalDeviceFeatures2";
-    case StructureType::ePhysicalDeviceProperties2: return "PhysicalDeviceProperties2";
-    case StructureType::eFormatProperties2: return "FormatProperties2";
-    case StructureType::eImageFormatProperties2: return "ImageFormatProperties2";
-    case StructureType::ePhysicalDeviceImageFormatInfo2: return "PhysicalDeviceImageFormatInfo2";
-    case StructureType::eQueueFamilyProperties2: return "QueueFamilyProperties2";
-    case StructureType::ePhysicalDeviceMemoryProperties2: return "PhysicalDeviceMemoryProperties2";
-    case StructureType::eSparseImageFormatProperties2: return "SparseImageFormatProperties2";
-    case StructureType::ePhysicalDeviceSparseImageFormatInfo2: return "PhysicalDeviceSparseImageFormatInfo2";
-    case StructureType::ePhysicalDevicePointClippingProperties: return "PhysicalDevicePointClippingProperties";
-    case StructureType::eRenderPassInputAttachmentAspectCreateInfo: return "RenderPassInputAttachmentAspectCreateInfo";
-    case StructureType::eImageViewUsageCreateInfo: return "ImageViewUsageCreateInfo";
-    case StructureType::ePipelineTessellationDomainOriginStateCreateInfo: return "PipelineTessellationDomainOriginStateCreateInfo";
-    case StructureType::eRenderPassMultiviewCreateInfo: return "RenderPassMultiviewCreateInfo";
-    case StructureType::ePhysicalDeviceMultiviewFeatures: return "PhysicalDeviceMultiviewFeatures";
-    case StructureType::ePhysicalDeviceMultiviewProperties: return "PhysicalDeviceMultiviewProperties";
-    case StructureType::ePhysicalDeviceVariablePointerFeatures: return "PhysicalDeviceVariablePointerFeatures";
-    case StructureType::eProtectedSubmitInfo: return "ProtectedSubmitInfo";
-    case StructureType::ePhysicalDeviceProtectedMemoryFeatures: return "PhysicalDeviceProtectedMemoryFeatures";
-    case StructureType::ePhysicalDeviceProtectedMemoryProperties: return "PhysicalDeviceProtectedMemoryProperties";
-    case StructureType::eDeviceQueueInfo2: return "DeviceQueueInfo2";
-    case StructureType::eSamplerYcbcrConversionCreateInfo: return "SamplerYcbcrConversionCreateInfo";
-    case StructureType::eSamplerYcbcrConversionInfo: return "SamplerYcbcrConversionInfo";
-    case StructureType::eBindImagePlaneMemoryInfo: return "BindImagePlaneMemoryInfo";
-    case StructureType::eImagePlaneMemoryRequirementsInfo: return "ImagePlaneMemoryRequirementsInfo";
-    case StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures: return "PhysicalDeviceSamplerYcbcrConversionFeatures";
-    case StructureType::eSamplerYcbcrConversionImageFormatProperties: return "SamplerYcbcrConversionImageFormatProperties";
-    case StructureType::eDescriptorUpdateTemplateCreateInfo: return "DescriptorUpdateTemplateCreateInfo";
-    case StructureType::ePhysicalDeviceExternalImageFormatInfo: return "PhysicalDeviceExternalImageFormatInfo";
-    case StructureType::eExternalImageFormatProperties: return "ExternalImageFormatProperties";
-    case StructureType::ePhysicalDeviceExternalBufferInfo: return "PhysicalDeviceExternalBufferInfo";
-    case StructureType::eExternalBufferProperties: return "ExternalBufferProperties";
-    case StructureType::ePhysicalDeviceIdProperties: return "PhysicalDeviceIdProperties";
-    case StructureType::eExternalMemoryBufferCreateInfo: return "ExternalMemoryBufferCreateInfo";
-    case StructureType::eExternalMemoryImageCreateInfo: return "ExternalMemoryImageCreateInfo";
-    case StructureType::eExportMemoryAllocateInfo: return "ExportMemoryAllocateInfo";
-    case StructureType::ePhysicalDeviceExternalFenceInfo: return "PhysicalDeviceExternalFenceInfo";
-    case StructureType::eExternalFenceProperties: return "ExternalFenceProperties";
-    case StructureType::eExportFenceCreateInfo: return "ExportFenceCreateInfo";
-    case StructureType::eExportSemaphoreCreateInfo: return "ExportSemaphoreCreateInfo";
-    case StructureType::ePhysicalDeviceExternalSemaphoreInfo: return "PhysicalDeviceExternalSemaphoreInfo";
-    case StructureType::eExternalSemaphoreProperties: return "ExternalSemaphoreProperties";
-    case StructureType::ePhysicalDeviceMaintenance3Properties: return "PhysicalDeviceMaintenance3Properties";
-    case StructureType::eDescriptorSetLayoutSupport: return "DescriptorSetLayoutSupport";
-    case StructureType::ePhysicalDeviceShaderDrawParameterFeatures: return "PhysicalDeviceShaderDrawParameterFeatures";
-    case StructureType::eSwapchainCreateInfoKHR: return "SwapchainCreateInfoKHR";
-    case StructureType::ePresentInfoKHR: return "PresentInfoKHR";
-    case StructureType::eDeviceGroupPresentCapabilitiesKHR: return "DeviceGroupPresentCapabilitiesKHR";
-    case StructureType::eImageSwapchainCreateInfoKHR: return "ImageSwapchainCreateInfoKHR";
-    case StructureType::eBindImageMemorySwapchainInfoKHR: return "BindImageMemorySwapchainInfoKHR";
-    case StructureType::eAcquireNextImageInfoKHR: return "AcquireNextImageInfoKHR";
-    case StructureType::eDeviceGroupPresentInfoKHR: return "DeviceGroupPresentInfoKHR";
-    case StructureType::eDeviceGroupSwapchainCreateInfoKHR: return "DeviceGroupSwapchainCreateInfoKHR";
-    case StructureType::eDisplayModeCreateInfoKHR: return "DisplayModeCreateInfoKHR";
-    case StructureType::eDisplaySurfaceCreateInfoKHR: return "DisplaySurfaceCreateInfoKHR";
-    case StructureType::eDisplayPresentInfoKHR: return "DisplayPresentInfoKHR";
-    case StructureType::eXlibSurfaceCreateInfoKHR: return "XlibSurfaceCreateInfoKHR";
-    case StructureType::eXcbSurfaceCreateInfoKHR: return "XcbSurfaceCreateInfoKHR";
-    case StructureType::eWaylandSurfaceCreateInfoKHR: return "WaylandSurfaceCreateInfoKHR";
-    case StructureType::eAndroidSurfaceCreateInfoKHR: return "AndroidSurfaceCreateInfoKHR";
-    case StructureType::eWin32SurfaceCreateInfoKHR: return "Win32SurfaceCreateInfoKHR";
-    case StructureType::eDebugReportCallbackCreateInfoEXT: return "DebugReportCallbackCreateInfoEXT";
-    case StructureType::ePipelineRasterizationStateRasterizationOrderAMD: return "PipelineRasterizationStateRasterizationOrderAMD";
-    case StructureType::eDebugMarkerObjectNameInfoEXT: return "DebugMarkerObjectNameInfoEXT";
-    case StructureType::eDebugMarkerObjectTagInfoEXT: return "DebugMarkerObjectTagInfoEXT";
-    case StructureType::eDebugMarkerMarkerInfoEXT: return "DebugMarkerMarkerInfoEXT";
-    case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV";
-    case StructureType::eDedicatedAllocationBufferCreateInfoNV: return "DedicatedAllocationBufferCreateInfoNV";
-    case StructureType::eDedicatedAllocationMemoryAllocateInfoNV: return "DedicatedAllocationMemoryAllocateInfoNV";
-    case StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT: return "PhysicalDeviceTransformFeedbackFeaturesEXT";
-    case StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT: return "PhysicalDeviceTransformFeedbackPropertiesEXT";
-    case StructureType::ePipelineRasterizationStateStreamCreateInfoEXT: return "PipelineRasterizationStateStreamCreateInfoEXT";
-    case StructureType::eTextureLodGatherFormatPropertiesAMD: return "TextureLodGatherFormatPropertiesAMD";
-    case StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV: return "PhysicalDeviceCornerSampledImageFeaturesNV";
-    case StructureType::eExternalMemoryImageCreateInfoNV: return "ExternalMemoryImageCreateInfoNV";
-    case StructureType::eExportMemoryAllocateInfoNV: return "ExportMemoryAllocateInfoNV";
-    case StructureType::eImportMemoryWin32HandleInfoNV: return "ImportMemoryWin32HandleInfoNV";
-    case StructureType::eExportMemoryWin32HandleInfoNV: return "ExportMemoryWin32HandleInfoNV";
-    case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV: return "Win32KeyedMutexAcquireReleaseInfoNV";
-    case StructureType::eValidationFlagsEXT: return "ValidationFlagsEXT";
-    case StructureType::eViSurfaceCreateInfoNN: return "ViSurfaceCreateInfoNN";
-    case StructureType::eImageViewAstcDecodeModeEXT: return "ImageViewAstcDecodeModeEXT";
-    case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT: return "PhysicalDeviceAstcDecodeFeaturesEXT";
-    case StructureType::eImportMemoryWin32HandleInfoKHR: return "ImportMemoryWin32HandleInfoKHR";
-    case StructureType::eExportMemoryWin32HandleInfoKHR: return "ExportMemoryWin32HandleInfoKHR";
-    case StructureType::eMemoryWin32HandlePropertiesKHR: return "MemoryWin32HandlePropertiesKHR";
-    case StructureType::eMemoryGetWin32HandleInfoKHR: return "MemoryGetWin32HandleInfoKHR";
-    case StructureType::eImportMemoryFdInfoKHR: return "ImportMemoryFdInfoKHR";
-    case StructureType::eMemoryFdPropertiesKHR: return "MemoryFdPropertiesKHR";
-    case StructureType::eMemoryGetFdInfoKHR: return "MemoryGetFdInfoKHR";
-    case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR: return "Win32KeyedMutexAcquireReleaseInfoKHR";
-    case StructureType::eImportSemaphoreWin32HandleInfoKHR: return "ImportSemaphoreWin32HandleInfoKHR";
-    case StructureType::eExportSemaphoreWin32HandleInfoKHR: return "ExportSemaphoreWin32HandleInfoKHR";
-    case StructureType::eD3D12FenceSubmitInfoKHR: return "D3D12FenceSubmitInfoKHR";
-    case StructureType::eSemaphoreGetWin32HandleInfoKHR: return "SemaphoreGetWin32HandleInfoKHR";
-    case StructureType::eImportSemaphoreFdInfoKHR: return "ImportSemaphoreFdInfoKHR";
-    case StructureType::eSemaphoreGetFdInfoKHR: return "SemaphoreGetFdInfoKHR";
-    case StructureType::ePhysicalDevicePushDescriptorPropertiesKHR: return "PhysicalDevicePushDescriptorPropertiesKHR";
-    case StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT: return "CommandBufferInheritanceConditionalRenderingInfoEXT";
-    case StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT: return "PhysicalDeviceConditionalRenderingFeaturesEXT";
-    case StructureType::eConditionalRenderingBeginInfoEXT: return "ConditionalRenderingBeginInfoEXT";
-    case StructureType::ePresentRegionsKHR: return "PresentRegionsKHR";
-    case StructureType::eObjectTableCreateInfoNVX: return "ObjectTableCreateInfoNVX";
-    case StructureType::eIndirectCommandsLayoutCreateInfoNVX: return "IndirectCommandsLayoutCreateInfoNVX";
-    case StructureType::eCmdProcessCommandsInfoNVX: return "CmdProcessCommandsInfoNVX";
-    case StructureType::eCmdReserveSpaceForCommandsInfoNVX: return "CmdReserveSpaceForCommandsInfoNVX";
-    case StructureType::eDeviceGeneratedCommandsLimitsNVX: return "DeviceGeneratedCommandsLimitsNVX";
-    case StructureType::eDeviceGeneratedCommandsFeaturesNVX: return "DeviceGeneratedCommandsFeaturesNVX";
-    case StructureType::ePipelineViewportWScalingStateCreateInfoNV: return "PipelineViewportWScalingStateCreateInfoNV";
-    case StructureType::eSurfaceCapabilities2EXT: return "SurfaceCapabilities2EXT";
-    case StructureType::eDisplayPowerInfoEXT: return "DisplayPowerInfoEXT";
-    case StructureType::eDeviceEventInfoEXT: return "DeviceEventInfoEXT";
-    case StructureType::eDisplayEventInfoEXT: return "DisplayEventInfoEXT";
-    case StructureType::eSwapchainCounterCreateInfoEXT: return "SwapchainCounterCreateInfoEXT";
-    case StructureType::ePresentTimesInfoGOOGLE: return "PresentTimesInfoGOOGLE";
-    case StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX: return "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX";
-    case StructureType::ePipelineViewportSwizzleStateCreateInfoNV: return "PipelineViewportSwizzleStateCreateInfoNV";
-    case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT: return "PhysicalDeviceDiscardRectanglePropertiesEXT";
-    case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT: return "PipelineDiscardRectangleStateCreateInfoEXT";
-    case StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT: return "PhysicalDeviceConservativeRasterizationPropertiesEXT";
-    case StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT: return "PipelineRasterizationConservativeStateCreateInfoEXT";
-    case StructureType::eHdrMetadataEXT: return "HdrMetadataEXT";
-    case StructureType::eAttachmentDescription2KHR: return "AttachmentDescription2KHR";
-    case StructureType::eAttachmentReference2KHR: return "AttachmentReference2KHR";
-    case StructureType::eSubpassDescription2KHR: return "SubpassDescription2KHR";
-    case StructureType::eSubpassDependency2KHR: return "SubpassDependency2KHR";
-    case StructureType::eRenderPassCreateInfo2KHR: return "RenderPassCreateInfo2KHR";
-    case StructureType::eSubpassBeginInfoKHR: return "SubpassBeginInfoKHR";
-    case StructureType::eSubpassEndInfoKHR: return "SubpassEndInfoKHR";
-    case StructureType::eSharedPresentSurfaceCapabilitiesKHR: return "SharedPresentSurfaceCapabilitiesKHR";
-    case StructureType::eImportFenceWin32HandleInfoKHR: return "ImportFenceWin32HandleInfoKHR";
-    case StructureType::eExportFenceWin32HandleInfoKHR: return "ExportFenceWin32HandleInfoKHR";
-    case StructureType::eFenceGetWin32HandleInfoKHR: return "FenceGetWin32HandleInfoKHR";
-    case StructureType::eImportFenceFdInfoKHR: return "ImportFenceFdInfoKHR";
-    case StructureType::eFenceGetFdInfoKHR: return "FenceGetFdInfoKHR";
-    case StructureType::ePhysicalDeviceSurfaceInfo2KHR: return "PhysicalDeviceSurfaceInfo2KHR";
-    case StructureType::eSurfaceCapabilities2KHR: return "SurfaceCapabilities2KHR";
-    case StructureType::eSurfaceFormat2KHR: return "SurfaceFormat2KHR";
-    case StructureType::eDisplayProperties2KHR: return "DisplayProperties2KHR";
-    case StructureType::eDisplayPlaneProperties2KHR: return "DisplayPlaneProperties2KHR";
-    case StructureType::eDisplayModeProperties2KHR: return "DisplayModeProperties2KHR";
-    case StructureType::eDisplayPlaneInfo2KHR: return "DisplayPlaneInfo2KHR";
-    case StructureType::eDisplayPlaneCapabilities2KHR: return "DisplayPlaneCapabilities2KHR";
-    case StructureType::eIosSurfaceCreateInfoMVK: return "IosSurfaceCreateInfoMVK";
-    case StructureType::eMacosSurfaceCreateInfoMVK: return "MacosSurfaceCreateInfoMVK";
-    case StructureType::eDebugUtilsObjectNameInfoEXT: return "DebugUtilsObjectNameInfoEXT";
-    case StructureType::eDebugUtilsObjectTagInfoEXT: return "DebugUtilsObjectTagInfoEXT";
-    case StructureType::eDebugUtilsLabelEXT: return "DebugUtilsLabelEXT";
-    case StructureType::eDebugUtilsMessengerCallbackDataEXT: return "DebugUtilsMessengerCallbackDataEXT";
-    case StructureType::eDebugUtilsMessengerCreateInfoEXT: return "DebugUtilsMessengerCreateInfoEXT";
-    case StructureType::eAndroidHardwareBufferUsageANDROID: return "AndroidHardwareBufferUsageANDROID";
-    case StructureType::eAndroidHardwareBufferPropertiesANDROID: return "AndroidHardwareBufferPropertiesANDROID";
-    case StructureType::eAndroidHardwareBufferFormatPropertiesANDROID: return "AndroidHardwareBufferFormatPropertiesANDROID";
-    case StructureType::eImportAndroidHardwareBufferInfoANDROID: return "ImportAndroidHardwareBufferInfoANDROID";
-    case StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID: return "MemoryGetAndroidHardwareBufferInfoANDROID";
-    case StructureType::eExternalFormatANDROID: return "ExternalFormatANDROID";
-    case StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT: return "PhysicalDeviceSamplerFilterMinmaxPropertiesEXT";
-    case StructureType::eSamplerReductionModeCreateInfoEXT: return "SamplerReductionModeCreateInfoEXT";
-    case StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT: return "PhysicalDeviceInlineUniformBlockFeaturesEXT";
-    case StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT: return "PhysicalDeviceInlineUniformBlockPropertiesEXT";
-    case StructureType::eWriteDescriptorSetInlineUniformBlockEXT: return "WriteDescriptorSetInlineUniformBlockEXT";
-    case StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT: return "DescriptorPoolInlineUniformBlockCreateInfoEXT";
-    case StructureType::eSampleLocationsInfoEXT: return "SampleLocationsInfoEXT";
-    case StructureType::eRenderPassSampleLocationsBeginInfoEXT: return "RenderPassSampleLocationsBeginInfoEXT";
-    case StructureType::ePipelineSampleLocationsStateCreateInfoEXT: return "PipelineSampleLocationsStateCreateInfoEXT";
-    case StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT: return "PhysicalDeviceSampleLocationsPropertiesEXT";
-    case StructureType::eMultisamplePropertiesEXT: return "MultisamplePropertiesEXT";
-    case StructureType::eImageFormatListCreateInfoKHR: return "ImageFormatListCreateInfoKHR";
-    case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT: return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT";
-    case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT: return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT";
-    case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT: return "PipelineColorBlendAdvancedStateCreateInfoEXT";
-    case StructureType::ePipelineCoverageToColorStateCreateInfoNV: return "PipelineCoverageToColorStateCreateInfoNV";
-    case StructureType::ePipelineCoverageModulationStateCreateInfoNV: return "PipelineCoverageModulationStateCreateInfoNV";
-    case StructureType::eDrmFormatModifierPropertiesListEXT: return "DrmFormatModifierPropertiesListEXT";
-    case StructureType::eDrmFormatModifierPropertiesEXT: return "DrmFormatModifierPropertiesEXT";
-    case StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT: return "PhysicalDeviceImageDrmFormatModifierInfoEXT";
-    case StructureType::eImageDrmFormatModifierListCreateInfoEXT: return "ImageDrmFormatModifierListCreateInfoEXT";
-    case StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT: return "ImageDrmFormatModifierExplicitCreateInfoEXT";
-    case StructureType::eImageDrmFormatModifierPropertiesEXT: return "ImageDrmFormatModifierPropertiesEXT";
-    case StructureType::eValidationCacheCreateInfoEXT: return "ValidationCacheCreateInfoEXT";
-    case StructureType::eShaderModuleValidationCacheCreateInfoEXT: return "ShaderModuleValidationCacheCreateInfoEXT";
-    case StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT: return "DescriptorSetLayoutBindingFlagsCreateInfoEXT";
-    case StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT: return "PhysicalDeviceDescriptorIndexingFeaturesEXT";
-    case StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT: return "PhysicalDeviceDescriptorIndexingPropertiesEXT";
-    case StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT: return "DescriptorSetVariableDescriptorCountAllocateInfoEXT";
-    case StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT: return "DescriptorSetVariableDescriptorCountLayoutSupportEXT";
-    case StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV: return "PipelineViewportShadingRateImageStateCreateInfoNV";
-    case StructureType::ePhysicalDeviceShadingRateImageFeaturesNV: return "PhysicalDeviceShadingRateImageFeaturesNV";
-    case StructureType::ePhysicalDeviceShadingRateImagePropertiesNV: return "PhysicalDeviceShadingRateImagePropertiesNV";
-    case StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV: return "PipelineViewportCoarseSampleOrderStateCreateInfoNV";
-    case StructureType::eRayTracingPipelineCreateInfoNV: return "RayTracingPipelineCreateInfoNV";
-    case StructureType::eAccelerationStructureCreateInfoNV: return "AccelerationStructureCreateInfoNV";
-    case StructureType::eGeometryNV: return "GeometryNV";
-    case StructureType::eGeometryTrianglesNV: return "GeometryTrianglesNV";
-    case StructureType::eGeometryAabbNV: return "GeometryAabbNV";
-    case StructureType::eBindAccelerationStructureMemoryInfoNV: return "BindAccelerationStructureMemoryInfoNV";
-    case StructureType::eWriteDescriptorSetAccelerationStructureNV: return "WriteDescriptorSetAccelerationStructureNV";
-    case StructureType::eAccelerationStructureMemoryRequirementsInfoNV: return "AccelerationStructureMemoryRequirementsInfoNV";
-    case StructureType::ePhysicalDeviceRayTracingPropertiesNV: return "PhysicalDeviceRayTracingPropertiesNV";
-    case StructureType::eRayTracingShaderGroupCreateInfoNV: return "RayTracingShaderGroupCreateInfoNV";
-    case StructureType::eAccelerationStructureInfoNV: return "AccelerationStructureInfoNV";
-    case StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV: return "PhysicalDeviceRepresentativeFragmentTestFeaturesNV";
-    case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV: return "PipelineRepresentativeFragmentTestStateCreateInfoNV";
-    case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT: return "DeviceQueueGlobalPriorityCreateInfoEXT";
-    case StructureType::ePhysicalDevice8BitStorageFeaturesKHR: return "PhysicalDevice8BitStorageFeaturesKHR";
-    case StructureType::eImportMemoryHostPointerInfoEXT: return "ImportMemoryHostPointerInfoEXT";
-    case StructureType::eMemoryHostPointerPropertiesEXT: return "MemoryHostPointerPropertiesEXT";
-    case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT: return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
-    case StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR: return "PhysicalDeviceShaderAtomicInt64FeaturesKHR";
-    case StructureType::eCalibratedTimestampInfoEXT: return "CalibratedTimestampInfoEXT";
-    case StructureType::ePhysicalDeviceShaderCorePropertiesAMD: return "PhysicalDeviceShaderCorePropertiesAMD";
-    case StructureType::eDeviceMemoryOverallocationCreateInfoAMD: return "DeviceMemoryOverallocationCreateInfoAMD";
-    case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT: return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT";
-    case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT: return "PipelineVertexInputDivisorStateCreateInfoEXT";
-    case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT: return "PhysicalDeviceVertexAttributeDivisorFeaturesEXT";
-    case StructureType::ePhysicalDeviceDriverPropertiesKHR: return "PhysicalDeviceDriverPropertiesKHR";
-    case StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV: return "PhysicalDeviceComputeShaderDerivativesFeaturesNV";
-    case StructureType::ePhysicalDeviceMeshShaderFeaturesNV: return "PhysicalDeviceMeshShaderFeaturesNV";
-    case StructureType::ePhysicalDeviceMeshShaderPropertiesNV: return "PhysicalDeviceMeshShaderPropertiesNV";
-    case StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV: return "PhysicalDeviceFragmentShaderBarycentricFeaturesNV";
-    case StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV: return "PhysicalDeviceShaderImageFootprintFeaturesNV";
-    case StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV: return "PipelineViewportExclusiveScissorStateCreateInfoNV";
-    case StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV: return "PhysicalDeviceExclusiveScissorFeaturesNV";
-    case StructureType::eCheckpointDataNV: return "CheckpointDataNV";
-    case StructureType::eQueueFamilyCheckpointPropertiesNV: return "QueueFamilyCheckpointPropertiesNV";
-    case StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR: return "PhysicalDeviceVulkanMemoryModelFeaturesKHR";
-    case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT: return "PhysicalDevicePciBusInfoPropertiesEXT";
-    case StructureType::eImagepipeSurfaceCreateInfoFUCHSIA: return "ImagepipeSurfaceCreateInfoFUCHSIA";
-    case StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT: return "PhysicalDeviceFragmentDensityMapFeaturesEXT";
-    case StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT: return "PhysicalDeviceFragmentDensityMapPropertiesEXT";
-    case StructureType::eRenderPassFragmentDensityMapCreateInfoEXT: return "RenderPassFragmentDensityMapCreateInfoEXT";
-    case StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT: return "PhysicalDeviceScalarBlockLayoutFeaturesEXT";
-    case StructureType::eImageStencilUsageCreateInfoEXT: return "ImageStencilUsageCreateInfoEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SubpassContents value)
-  {
-    switch (value)
-    {
-    case SubpassContents::eInline: return "Inline";
-    case SubpassContents::eSecondaryCommandBuffers: return "SecondaryCommandBuffers";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DynamicState value)
-  {
-    switch (value)
-    {
-    case DynamicState::eViewport: return "Viewport";
-    case DynamicState::eScissor: return "Scissor";
-    case DynamicState::eLineWidth: return "LineWidth";
-    case DynamicState::eDepthBias: return "DepthBias";
-    case DynamicState::eBlendConstants: return "BlendConstants";
-    case DynamicState::eDepthBounds: return "DepthBounds";
-    case DynamicState::eStencilCompareMask: return "StencilCompareMask";
-    case DynamicState::eStencilWriteMask: return "StencilWriteMask";
-    case DynamicState::eStencilReference: return "StencilReference";
-    case DynamicState::eViewportWScalingNV: return "ViewportWScalingNV";
-    case DynamicState::eDiscardRectangleEXT: return "DiscardRectangleEXT";
-    case DynamicState::eSampleLocationsEXT: return "SampleLocationsEXT";
-    case DynamicState::eViewportShadingRatePaletteNV: return "ViewportShadingRatePaletteNV";
-    case DynamicState::eViewportCoarseSampleOrderNV: return "ViewportCoarseSampleOrderNV";
-    case DynamicState::eExclusiveScissorNV: return "ExclusiveScissorNV";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateType value)
-  {
-    switch (value)
-    {
-    case DescriptorUpdateTemplateType::eDescriptorSet: return "DescriptorSet";
-    case DescriptorUpdateTemplateType::ePushDescriptorsKHR: return "PushDescriptorsKHR";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ObjectType value)
-  {
-    switch (value)
-    {
-    case ObjectType::eUnknown: return "Unknown";
-    case ObjectType::eInstance: return "Instance";
-    case ObjectType::ePhysicalDevice: return "PhysicalDevice";
-    case ObjectType::eDevice: return "Device";
-    case ObjectType::eQueue: return "Queue";
-    case ObjectType::eSemaphore: return "Semaphore";
-    case ObjectType::eCommandBuffer: return "CommandBuffer";
-    case ObjectType::eFence: return "Fence";
-    case ObjectType::eDeviceMemory: return "DeviceMemory";
-    case ObjectType::eBuffer: return "Buffer";
-    case ObjectType::eImage: return "Image";
-    case ObjectType::eEvent: return "Event";
-    case ObjectType::eQueryPool: return "QueryPool";
-    case ObjectType::eBufferView: return "BufferView";
-    case ObjectType::eImageView: return "ImageView";
-    case ObjectType::eShaderModule: return "ShaderModule";
-    case ObjectType::ePipelineCache: return "PipelineCache";
-    case ObjectType::ePipelineLayout: return "PipelineLayout";
-    case ObjectType::eRenderPass: return "RenderPass";
-    case ObjectType::ePipeline: return "Pipeline";
-    case ObjectType::eDescriptorSetLayout: return "DescriptorSetLayout";
-    case ObjectType::eSampler: return "Sampler";
-    case ObjectType::eDescriptorPool: return "DescriptorPool";
-    case ObjectType::eDescriptorSet: return "DescriptorSet";
-    case ObjectType::eFramebuffer: return "Framebuffer";
-    case ObjectType::eCommandPool: return "CommandPool";
-    case ObjectType::eSamplerYcbcrConversion: return "SamplerYcbcrConversion";
-    case ObjectType::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate";
-    case ObjectType::eSurfaceKHR: return "SurfaceKHR";
-    case ObjectType::eSwapchainKHR: return "SwapchainKHR";
-    case ObjectType::eDisplayKHR: return "DisplayKHR";
-    case ObjectType::eDisplayModeKHR: return "DisplayModeKHR";
-    case ObjectType::eDebugReportCallbackEXT: return "DebugReportCallbackEXT";
-    case ObjectType::eObjectTableNVX: return "ObjectTableNVX";
-    case ObjectType::eIndirectCommandsLayoutNVX: return "IndirectCommandsLayoutNVX";
-    case ObjectType::eDebugUtilsMessengerEXT: return "DebugUtilsMessengerEXT";
-    case ObjectType::eValidationCacheEXT: return "ValidationCacheEXT";
-    case ObjectType::eAccelerationStructureNV: return "AccelerationStructureNV";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueueFlagBits value)
-  {
-    switch (value)
-    {
-    case QueueFlagBits::eGraphics: return "Graphics";
-    case QueueFlagBits::eCompute: return "Compute";
-    case QueueFlagBits::eTransfer: return "Transfer";
-    case QueueFlagBits::eSparseBinding: return "SparseBinding";
-    case QueueFlagBits::eProtected: return "Protected";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueueFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & QueueFlagBits::eGraphics) result += "Graphics | ";
-    if (value & QueueFlagBits::eCompute) result += "Compute | ";
-    if (value & QueueFlagBits::eTransfer) result += "Transfer | ";
-    if (value & QueueFlagBits::eSparseBinding) result += "SparseBinding | ";
-    if (value & QueueFlagBits::eProtected) result += "Protected | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case DeviceQueueCreateFlagBits::eProtected: return "Protected";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DeviceQueueCreateFlagBits::eProtected) result += "Protected | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryPropertyFlagBits value)
-  {
-    switch (value)
-    {
-    case MemoryPropertyFlagBits::eDeviceLocal: return "DeviceLocal";
-    case MemoryPropertyFlagBits::eHostVisible: return "HostVisible";
-    case MemoryPropertyFlagBits::eHostCoherent: return "HostCoherent";
-    case MemoryPropertyFlagBits::eHostCached: return "HostCached";
-    case MemoryPropertyFlagBits::eLazilyAllocated: return "LazilyAllocated";
-    case MemoryPropertyFlagBits::eProtected: return "Protected";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryPropertyFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & MemoryPropertyFlagBits::eDeviceLocal) result += "DeviceLocal | ";
-    if (value & MemoryPropertyFlagBits::eHostVisible) result += "HostVisible | ";
-    if (value & MemoryPropertyFlagBits::eHostCoherent) result += "HostCoherent | ";
-    if (value & MemoryPropertyFlagBits::eHostCached) result += "HostCached | ";
-    if (value & MemoryPropertyFlagBits::eLazilyAllocated) result += "LazilyAllocated | ";
-    if (value & MemoryPropertyFlagBits::eProtected) result += "Protected | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryHeapFlagBits value)
-  {
-    switch (value)
-    {
-    case MemoryHeapFlagBits::eDeviceLocal: return "DeviceLocal";
-    case MemoryHeapFlagBits::eMultiInstance: return "MultiInstance";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryHeapFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & MemoryHeapFlagBits::eDeviceLocal) result += "DeviceLocal | ";
-    if (value & MemoryHeapFlagBits::eMultiInstance) result += "MultiInstance | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AccessFlagBits value)
-  {
-    switch (value)
-    {
-    case AccessFlagBits::eIndirectCommandRead: return "IndirectCommandRead";
-    case AccessFlagBits::eIndexRead: return "IndexRead";
-    case AccessFlagBits::eVertexAttributeRead: return "VertexAttributeRead";
-    case AccessFlagBits::eUniformRead: return "UniformRead";
-    case AccessFlagBits::eInputAttachmentRead: return "InputAttachmentRead";
-    case AccessFlagBits::eShaderRead: return "ShaderRead";
-    case AccessFlagBits::eShaderWrite: return "ShaderWrite";
-    case AccessFlagBits::eColorAttachmentRead: return "ColorAttachmentRead";
-    case AccessFlagBits::eColorAttachmentWrite: return "ColorAttachmentWrite";
-    case AccessFlagBits::eDepthStencilAttachmentRead: return "DepthStencilAttachmentRead";
-    case AccessFlagBits::eDepthStencilAttachmentWrite: return "DepthStencilAttachmentWrite";
-    case AccessFlagBits::eTransferRead: return "TransferRead";
-    case AccessFlagBits::eTransferWrite: return "TransferWrite";
-    case AccessFlagBits::eHostRead: return "HostRead";
-    case AccessFlagBits::eHostWrite: return "HostWrite";
-    case AccessFlagBits::eMemoryRead: return "MemoryRead";
-    case AccessFlagBits::eMemoryWrite: return "MemoryWrite";
-    case AccessFlagBits::eTransformFeedbackWriteEXT: return "TransformFeedbackWriteEXT";
-    case AccessFlagBits::eTransformFeedbackCounterReadEXT: return "TransformFeedbackCounterReadEXT";
-    case AccessFlagBits::eTransformFeedbackCounterWriteEXT: return "TransformFeedbackCounterWriteEXT";
-    case AccessFlagBits::eConditionalRenderingReadEXT: return "ConditionalRenderingReadEXT";
-    case AccessFlagBits::eCommandProcessReadNVX: return "CommandProcessReadNVX";
-    case AccessFlagBits::eCommandProcessWriteNVX: return "CommandProcessWriteNVX";
-    case AccessFlagBits::eColorAttachmentReadNoncoherentEXT: return "ColorAttachmentReadNoncoherentEXT";
-    case AccessFlagBits::eShadingRateImageReadNV: return "ShadingRateImageReadNV";
-    case AccessFlagBits::eAccelerationStructureReadNV: return "AccelerationStructureReadNV";
-    case AccessFlagBits::eAccelerationStructureWriteNV: return "AccelerationStructureWriteNV";
-    case AccessFlagBits::eFragmentDensityMapReadEXT: return "FragmentDensityMapReadEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AccessFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & AccessFlagBits::eIndirectCommandRead) result += "IndirectCommandRead | ";
-    if (value & AccessFlagBits::eIndexRead) result += "IndexRead | ";
-    if (value & AccessFlagBits::eVertexAttributeRead) result += "VertexAttributeRead | ";
-    if (value & AccessFlagBits::eUniformRead) result += "UniformRead | ";
-    if (value & AccessFlagBits::eInputAttachmentRead) result += "InputAttachmentRead | ";
-    if (value & AccessFlagBits::eShaderRead) result += "ShaderRead | ";
-    if (value & AccessFlagBits::eShaderWrite) result += "ShaderWrite | ";
-    if (value & AccessFlagBits::eColorAttachmentRead) result += "ColorAttachmentRead | ";
-    if (value & AccessFlagBits::eColorAttachmentWrite) result += "ColorAttachmentWrite | ";
-    if (value & AccessFlagBits::eDepthStencilAttachmentRead) result += "DepthStencilAttachmentRead | ";
-    if (value & AccessFlagBits::eDepthStencilAttachmentWrite) result += "DepthStencilAttachmentWrite | ";
-    if (value & AccessFlagBits::eTransferRead) result += "TransferRead | ";
-    if (value & AccessFlagBits::eTransferWrite) result += "TransferWrite | ";
-    if (value & AccessFlagBits::eHostRead) result += "HostRead | ";
-    if (value & AccessFlagBits::eHostWrite) result += "HostWrite | ";
-    if (value & AccessFlagBits::eMemoryRead) result += "MemoryRead | ";
-    if (value & AccessFlagBits::eMemoryWrite) result += "MemoryWrite | ";
-    if (value & AccessFlagBits::eTransformFeedbackWriteEXT) result += "TransformFeedbackWriteEXT | ";
-    if (value & AccessFlagBits::eTransformFeedbackCounterReadEXT) result += "TransformFeedbackCounterReadEXT | ";
-    if (value & AccessFlagBits::eTransformFeedbackCounterWriteEXT) result += "TransformFeedbackCounterWriteEXT | ";
-    if (value & AccessFlagBits::eConditionalRenderingReadEXT) result += "ConditionalRenderingReadEXT | ";
-    if (value & AccessFlagBits::eCommandProcessReadNVX) result += "CommandProcessReadNVX | ";
-    if (value & AccessFlagBits::eCommandProcessWriteNVX) result += "CommandProcessWriteNVX | ";
-    if (value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT) result += "ColorAttachmentReadNoncoherentEXT | ";
-    if (value & AccessFlagBits::eShadingRateImageReadNV) result += "ShadingRateImageReadNV | ";
-    if (value & AccessFlagBits::eAccelerationStructureReadNV) result += "AccelerationStructureReadNV | ";
-    if (value & AccessFlagBits::eAccelerationStructureWriteNV) result += "AccelerationStructureWriteNV | ";
-    if (value & AccessFlagBits::eFragmentDensityMapReadEXT) result += "FragmentDensityMapReadEXT | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BufferUsageFlagBits value)
-  {
-    switch (value)
-    {
-    case BufferUsageFlagBits::eTransferSrc: return "TransferSrc";
-    case BufferUsageFlagBits::eTransferDst: return "TransferDst";
-    case BufferUsageFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer";
-    case BufferUsageFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer";
-    case BufferUsageFlagBits::eUniformBuffer: return "UniformBuffer";
-    case BufferUsageFlagBits::eStorageBuffer: return "StorageBuffer";
-    case BufferUsageFlagBits::eIndexBuffer: return "IndexBuffer";
-    case BufferUsageFlagBits::eVertexBuffer: return "VertexBuffer";
-    case BufferUsageFlagBits::eIndirectBuffer: return "IndirectBuffer";
-    case BufferUsageFlagBits::eTransformFeedbackBufferEXT: return "TransformFeedbackBufferEXT";
-    case BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT: return "TransformFeedbackCounterBufferEXT";
-    case BufferUsageFlagBits::eConditionalRenderingEXT: return "ConditionalRenderingEXT";
-    case BufferUsageFlagBits::eRayTracingNV: return "RayTracingNV";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BufferUsageFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & BufferUsageFlagBits::eTransferSrc) result += "TransferSrc | ";
-    if (value & BufferUsageFlagBits::eTransferDst) result += "TransferDst | ";
-    if (value & BufferUsageFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | ";
-    if (value & BufferUsageFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | ";
-    if (value & BufferUsageFlagBits::eUniformBuffer) result += "UniformBuffer | ";
-    if (value & BufferUsageFlagBits::eStorageBuffer) result += "StorageBuffer | ";
-    if (value & BufferUsageFlagBits::eIndexBuffer) result += "IndexBuffer | ";
-    if (value & BufferUsageFlagBits::eVertexBuffer) result += "VertexBuffer | ";
-    if (value & BufferUsageFlagBits::eIndirectBuffer) result += "IndirectBuffer | ";
-    if (value & BufferUsageFlagBits::eTransformFeedbackBufferEXT) result += "TransformFeedbackBufferEXT | ";
-    if (value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) result += "TransformFeedbackCounterBufferEXT | ";
-    if (value & BufferUsageFlagBits::eConditionalRenderingEXT) result += "ConditionalRenderingEXT | ";
-    if (value & BufferUsageFlagBits::eRayTracingNV) result += "RayTracingNV | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BufferCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case BufferCreateFlagBits::eSparseBinding: return "SparseBinding";
-    case BufferCreateFlagBits::eSparseResidency: return "SparseResidency";
-    case BufferCreateFlagBits::eSparseAliased: return "SparseAliased";
-    case BufferCreateFlagBits::eProtected: return "Protected";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BufferCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & BufferCreateFlagBits::eSparseBinding) result += "SparseBinding | ";
-    if (value & BufferCreateFlagBits::eSparseResidency) result += "SparseResidency | ";
-    if (value & BufferCreateFlagBits::eSparseAliased) result += "SparseAliased | ";
-    if (value & BufferCreateFlagBits::eProtected) result += "Protected | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ShaderStageFlagBits value)
-  {
-    switch (value)
-    {
-    case ShaderStageFlagBits::eVertex: return "Vertex";
-    case ShaderStageFlagBits::eTessellationControl: return "TessellationControl";
-    case ShaderStageFlagBits::eTessellationEvaluation: return "TessellationEvaluation";
-    case ShaderStageFlagBits::eGeometry: return "Geometry";
-    case ShaderStageFlagBits::eFragment: return "Fragment";
-    case ShaderStageFlagBits::eCompute: return "Compute";
-    case ShaderStageFlagBits::eAllGraphics: return "AllGraphics";
-    case ShaderStageFlagBits::eAll: return "All";
-    case ShaderStageFlagBits::eRaygenNV: return "RaygenNV";
-    case ShaderStageFlagBits::eAnyHitNV: return "AnyHitNV";
-    case ShaderStageFlagBits::eClosestHitNV: return "ClosestHitNV";
-    case ShaderStageFlagBits::eMissNV: return "MissNV";
-    case ShaderStageFlagBits::eIntersectionNV: return "IntersectionNV";
-    case ShaderStageFlagBits::eCallableNV: return "CallableNV";
-    case ShaderStageFlagBits::eTaskNV: return "TaskNV";
-    case ShaderStageFlagBits::eMeshNV: return "MeshNV";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ShaderStageFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ShaderStageFlagBits::eVertex) result += "Vertex | ";
-    if (value & ShaderStageFlagBits::eTessellationControl) result += "TessellationControl | ";
-    if (value & ShaderStageFlagBits::eTessellationEvaluation) result += "TessellationEvaluation | ";
-    if (value & ShaderStageFlagBits::eGeometry) result += "Geometry | ";
-    if (value & ShaderStageFlagBits::eFragment) result += "Fragment | ";
-    if (value & ShaderStageFlagBits::eCompute) result += "Compute | ";
-    if (value & ShaderStageFlagBits::eAllGraphics) result += "AllGraphics | ";
-    if (value & ShaderStageFlagBits::eAll) result += "All | ";
-    if (value & ShaderStageFlagBits::eRaygenNV) result += "RaygenNV | ";
-    if (value & ShaderStageFlagBits::eAnyHitNV) result += "AnyHitNV | ";
-    if (value & ShaderStageFlagBits::eClosestHitNV) result += "ClosestHitNV | ";
-    if (value & ShaderStageFlagBits::eMissNV) result += "MissNV | ";
-    if (value & ShaderStageFlagBits::eIntersectionNV) result += "IntersectionNV | ";
-    if (value & ShaderStageFlagBits::eCallableNV) result += "CallableNV | ";
-    if (value & ShaderStageFlagBits::eTaskNV) result += "TaskNV | ";
-    if (value & ShaderStageFlagBits::eMeshNV) result += "MeshNV | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageUsageFlagBits value)
-  {
-    switch (value)
-    {
-    case ImageUsageFlagBits::eTransferSrc: return "TransferSrc";
-    case ImageUsageFlagBits::eTransferDst: return "TransferDst";
-    case ImageUsageFlagBits::eSampled: return "Sampled";
-    case ImageUsageFlagBits::eStorage: return "Storage";
-    case ImageUsageFlagBits::eColorAttachment: return "ColorAttachment";
-    case ImageUsageFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment";
-    case ImageUsageFlagBits::eTransientAttachment: return "TransientAttachment";
-    case ImageUsageFlagBits::eInputAttachment: return "InputAttachment";
-    case ImageUsageFlagBits::eShadingRateImageNV: return "ShadingRateImageNV";
-    case ImageUsageFlagBits::eFragmentDensityMapEXT: return "FragmentDensityMapEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageUsageFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ImageUsageFlagBits::eTransferSrc) result += "TransferSrc | ";
-    if (value & ImageUsageFlagBits::eTransferDst) result += "TransferDst | ";
-    if (value & ImageUsageFlagBits::eSampled) result += "Sampled | ";
-    if (value & ImageUsageFlagBits::eStorage) result += "Storage | ";
-    if (value & ImageUsageFlagBits::eColorAttachment) result += "ColorAttachment | ";
-    if (value & ImageUsageFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | ";
-    if (value & ImageUsageFlagBits::eTransientAttachment) result += "TransientAttachment | ";
-    if (value & ImageUsageFlagBits::eInputAttachment) result += "InputAttachment | ";
-    if (value & ImageUsageFlagBits::eShadingRateImageNV) result += "ShadingRateImageNV | ";
-    if (value & ImageUsageFlagBits::eFragmentDensityMapEXT) result += "FragmentDensityMapEXT | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case ImageCreateFlagBits::eSparseBinding: return "SparseBinding";
-    case ImageCreateFlagBits::eSparseResidency: return "SparseResidency";
-    case ImageCreateFlagBits::eSparseAliased: return "SparseAliased";
-    case ImageCreateFlagBits::eMutableFormat: return "MutableFormat";
-    case ImageCreateFlagBits::eCubeCompatible: return "CubeCompatible";
-    case ImageCreateFlagBits::eAlias: return "Alias";
-    case ImageCreateFlagBits::eSplitInstanceBindRegions: return "SplitInstanceBindRegions";
-    case ImageCreateFlagBits::e2DArrayCompatible: return "2DArrayCompatible";
-    case ImageCreateFlagBits::eBlockTexelViewCompatible: return "BlockTexelViewCompatible";
-    case ImageCreateFlagBits::eExtendedUsage: return "ExtendedUsage";
-    case ImageCreateFlagBits::eProtected: return "Protected";
-    case ImageCreateFlagBits::eDisjoint: return "Disjoint";
-    case ImageCreateFlagBits::eCornerSampledNV: return "CornerSampledNV";
-    case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT: return "SampleLocationsCompatibleDepthEXT";
-    case ImageCreateFlagBits::eSubsampledEXT: return "SubsampledEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ImageCreateFlagBits::eSparseBinding) result += "SparseBinding | ";
-    if (value & ImageCreateFlagBits::eSparseResidency) result += "SparseResidency | ";
-    if (value & ImageCreateFlagBits::eSparseAliased) result += "SparseAliased | ";
-    if (value & ImageCreateFlagBits::eMutableFormat) result += "MutableFormat | ";
-    if (value & ImageCreateFlagBits::eCubeCompatible) result += "CubeCompatible | ";
-    if (value & ImageCreateFlagBits::eAlias) result += "Alias | ";
-    if (value & ImageCreateFlagBits::eSplitInstanceBindRegions) result += "SplitInstanceBindRegions | ";
-    if (value & ImageCreateFlagBits::e2DArrayCompatible) result += "2DArrayCompatible | ";
-    if (value & ImageCreateFlagBits::eBlockTexelViewCompatible) result += "BlockTexelViewCompatible | ";
-    if (value & ImageCreateFlagBits::eExtendedUsage) result += "ExtendedUsage | ";
-    if (value & ImageCreateFlagBits::eProtected) result += "Protected | ";
-    if (value & ImageCreateFlagBits::eDisjoint) result += "Disjoint | ";
-    if (value & ImageCreateFlagBits::eCornerSampledNV) result += "CornerSampledNV | ";
-    if (value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) result += "SampleLocationsCompatibleDepthEXT | ";
-    if (value & ImageCreateFlagBits::eSubsampledEXT) result += "SubsampledEXT | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT: return "FragmentDensityMapDynamicEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT) result += "FragmentDensityMapDynamicEXT | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case SamplerCreateFlagBits::eSubsampledEXT: return "SubsampledEXT";
-    case SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT: return "SubsampledCoarseReconstructionEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SamplerCreateFlagBits::eSubsampledEXT) result += "SubsampledEXT | ";
-    if (value & SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT) result += "SubsampledCoarseReconstructionEXT | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case PipelineCreateFlagBits::eDisableOptimization: return "DisableOptimization";
-    case PipelineCreateFlagBits::eAllowDerivatives: return "AllowDerivatives";
-    case PipelineCreateFlagBits::eDerivative: return "Derivative";
-    case PipelineCreateFlagBits::eViewIndexFromDeviceIndex: return "ViewIndexFromDeviceIndex";
-    case PipelineCreateFlagBits::eDispatchBase: return "DispatchBase";
-    case PipelineCreateFlagBits::eDeferCompileNV: return "DeferCompileNV";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & PipelineCreateFlagBits::eDisableOptimization) result += "DisableOptimization | ";
-    if (value & PipelineCreateFlagBits::eAllowDerivatives) result += "AllowDerivatives | ";
-    if (value & PipelineCreateFlagBits::eDerivative) result += "Derivative | ";
-    if (value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex) result += "ViewIndexFromDeviceIndex | ";
-    if (value & PipelineCreateFlagBits::eDispatchBase) result += "DispatchBase | ";
-    if (value & PipelineCreateFlagBits::eDeferCompileNV) result += "DeferCompileNV | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ColorComponentFlagBits value)
-  {
-    switch (value)
-    {
-    case ColorComponentFlagBits::eR: return "R";
-    case ColorComponentFlagBits::eG: return "G";
-    case ColorComponentFlagBits::eB: return "B";
-    case ColorComponentFlagBits::eA: return "A";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ColorComponentFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ColorComponentFlagBits::eR) result += "R | ";
-    if (value & ColorComponentFlagBits::eG) result += "G | ";
-    if (value & ColorComponentFlagBits::eB) result += "B | ";
-    if (value & ColorComponentFlagBits::eA) result += "A | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FenceCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case FenceCreateFlagBits::eSignaled: return "Signaled";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FenceCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & FenceCreateFlagBits::eSignaled) result += "Signaled | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlagBits value)
-  {
-    switch (value)
-    {
-    case FormatFeatureFlagBits::eSampledImage: return "SampledImage";
-    case FormatFeatureFlagBits::eStorageImage: return "StorageImage";
-    case FormatFeatureFlagBits::eStorageImageAtomic: return "StorageImageAtomic";
-    case FormatFeatureFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer";
-    case FormatFeatureFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer";
-    case FormatFeatureFlagBits::eStorageTexelBufferAtomic: return "StorageTexelBufferAtomic";
-    case FormatFeatureFlagBits::eVertexBuffer: return "VertexBuffer";
-    case FormatFeatureFlagBits::eColorAttachment: return "ColorAttachment";
-    case FormatFeatureFlagBits::eColorAttachmentBlend: return "ColorAttachmentBlend";
-    case FormatFeatureFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment";
-    case FormatFeatureFlagBits::eBlitSrc: return "BlitSrc";
-    case FormatFeatureFlagBits::eBlitDst: return "BlitDst";
-    case FormatFeatureFlagBits::eSampledImageFilterLinear: return "SampledImageFilterLinear";
-    case FormatFeatureFlagBits::eTransferSrc: return "TransferSrc";
-    case FormatFeatureFlagBits::eTransferDst: return "TransferDst";
-    case FormatFeatureFlagBits::eMidpointChromaSamples: return "MidpointChromaSamples";
-    case FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter: return "SampledImageYcbcrConversionLinearFilter";
-    case FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter: return "SampledImageYcbcrConversionSeparateReconstructionFilter";
-    case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit: return "SampledImageYcbcrConversionChromaReconstructionExplicit";
-    case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable: return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable";
-    case FormatFeatureFlagBits::eDisjoint: return "Disjoint";
-    case FormatFeatureFlagBits::eCositedChromaSamples: return "CositedChromaSamples";
-    case FormatFeatureFlagBits::eSampledImageFilterCubicIMG: return "SampledImageFilterCubicIMG";
-    case FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT: return "SampledImageFilterMinmaxEXT";
-    case FormatFeatureFlagBits::eFragmentDensityMapEXT: return "FragmentDensityMapEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & FormatFeatureFlagBits::eSampledImage) result += "SampledImage | ";
-    if (value & FormatFeatureFlagBits::eStorageImage) result += "StorageImage | ";
-    if (value & FormatFeatureFlagBits::eStorageImageAtomic) result += "StorageImageAtomic | ";
-    if (value & FormatFeatureFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | ";
-    if (value & FormatFeatureFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | ";
-    if (value & FormatFeatureFlagBits::eStorageTexelBufferAtomic) result += "StorageTexelBufferAtomic | ";
-    if (value & FormatFeatureFlagBits::eVertexBuffer) result += "VertexBuffer | ";
-    if (value & FormatFeatureFlagBits::eColorAttachment) result += "ColorAttachment | ";
-    if (value & FormatFeatureFlagBits::eColorAttachmentBlend) result += "ColorAttachmentBlend | ";
-    if (value & FormatFeatureFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | ";
-    if (value & FormatFeatureFlagBits::eBlitSrc) result += "BlitSrc | ";
-    if (value & FormatFeatureFlagBits::eBlitDst) result += "BlitDst | ";
-    if (value & FormatFeatureFlagBits::eSampledImageFilterLinear) result += "SampledImageFilterLinear | ";
-    if (value & FormatFeatureFlagBits::eTransferSrc) result += "TransferSrc | ";
-    if (value & FormatFeatureFlagBits::eTransferDst) result += "TransferDst | ";
-    if (value & FormatFeatureFlagBits::eMidpointChromaSamples) result += "MidpointChromaSamples | ";
-    if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter) result += "SampledImageYcbcrConversionLinearFilter | ";
-    if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter) result += "SampledImageYcbcrConversionSeparateReconstructionFilter | ";
-    if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit) result += "SampledImageYcbcrConversionChromaReconstructionExplicit | ";
-    if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable) result += "SampledImageYcbcrConversionChromaReconstructionExplicitForceable | ";
-    if (value & FormatFeatureFlagBits::eDisjoint) result += "Disjoint | ";
-    if (value & FormatFeatureFlagBits::eCositedChromaSamples) result += "CositedChromaSamples | ";
-    if (value & FormatFeatureFlagBits::eSampledImageFilterCubicIMG) result += "SampledImageFilterCubicIMG | ";
-    if (value & FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) result += "SampledImageFilterMinmaxEXT | ";
-    if (value & FormatFeatureFlagBits::eFragmentDensityMapEXT) result += "FragmentDensityMapEXT | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryControlFlagBits value)
-  {
-    switch (value)
-    {
-    case QueryControlFlagBits::ePrecise: return "Precise";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryControlFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & QueryControlFlagBits::ePrecise) result += "Precise | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryResultFlagBits value)
-  {
-    switch (value)
-    {
-    case QueryResultFlagBits::e64: return "64";
-    case QueryResultFlagBits::eWait: return "Wait";
-    case QueryResultFlagBits::eWithAvailability: return "WithAvailability";
-    case QueryResultFlagBits::ePartial: return "Partial";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryResultFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & QueryResultFlagBits::e64) result += "64 | ";
-    if (value & QueryResultFlagBits::eWait) result += "Wait | ";
-    if (value & QueryResultFlagBits::eWithAvailability) result += "WithAvailability | ";
-    if (value & QueryResultFlagBits::ePartial) result += "Partial | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlagBits value)
-  {
-    switch (value)
-    {
-    case CommandBufferUsageFlagBits::eOneTimeSubmit: return "OneTimeSubmit";
-    case CommandBufferUsageFlagBits::eRenderPassContinue: return "RenderPassContinue";
-    case CommandBufferUsageFlagBits::eSimultaneousUse: return "SimultaneousUse";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & CommandBufferUsageFlagBits::eOneTimeSubmit) result += "OneTimeSubmit | ";
-    if (value & CommandBufferUsageFlagBits::eRenderPassContinue) result += "RenderPassContinue | ";
-    if (value & CommandBufferUsageFlagBits::eSimultaneousUse) result += "SimultaneousUse | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlagBits value)
-  {
-    switch (value)
-    {
-    case QueryPipelineStatisticFlagBits::eInputAssemblyVertices: return "InputAssemblyVertices";
-    case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives: return "InputAssemblyPrimitives";
-    case QueryPipelineStatisticFlagBits::eVertexShaderInvocations: return "VertexShaderInvocations";
-    case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations: return "GeometryShaderInvocations";
-    case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives: return "GeometryShaderPrimitives";
-    case QueryPipelineStatisticFlagBits::eClippingInvocations: return "ClippingInvocations";
-    case QueryPipelineStatisticFlagBits::eClippingPrimitives: return "ClippingPrimitives";
-    case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations: return "FragmentShaderInvocations";
-    case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches: return "TessellationControlShaderPatches";
-    case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations: return "TessellationEvaluationShaderInvocations";
-    case QueryPipelineStatisticFlagBits::eComputeShaderInvocations: return "ComputeShaderInvocations";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices) result += "InputAssemblyVertices | ";
-    if (value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) result += "InputAssemblyPrimitives | ";
-    if (value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations) result += "VertexShaderInvocations | ";
-    if (value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) result += "GeometryShaderInvocations | ";
-    if (value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) result += "GeometryShaderPrimitives | ";
-    if (value & QueryPipelineStatisticFlagBits::eClippingInvocations) result += "ClippingInvocations | ";
-    if (value & QueryPipelineStatisticFlagBits::eClippingPrimitives) result += "ClippingPrimitives | ";
-    if (value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) result += "FragmentShaderInvocations | ";
-    if (value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) result += "TessellationControlShaderPatches | ";
-    if (value & QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) result += "TessellationEvaluationShaderInvocations | ";
-    if (value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations) result += "ComputeShaderInvocations | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageAspectFlagBits value)
-  {
-    switch (value)
-    {
-    case ImageAspectFlagBits::eColor: return "Color";
-    case ImageAspectFlagBits::eDepth: return "Depth";
-    case ImageAspectFlagBits::eStencil: return "Stencil";
-    case ImageAspectFlagBits::eMetadata: return "Metadata";
-    case ImageAspectFlagBits::ePlane0: return "Plane0";
-    case ImageAspectFlagBits::ePlane1: return "Plane1";
-    case ImageAspectFlagBits::ePlane2: return "Plane2";
-    case ImageAspectFlagBits::eMemoryPlane0EXT: return "MemoryPlane0EXT";
-    case ImageAspectFlagBits::eMemoryPlane1EXT: return "MemoryPlane1EXT";
-    case ImageAspectFlagBits::eMemoryPlane2EXT: return "MemoryPlane2EXT";
-    case ImageAspectFlagBits::eMemoryPlane3EXT: return "MemoryPlane3EXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageAspectFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ImageAspectFlagBits::eColor) result += "Color | ";
-    if (value & ImageAspectFlagBits::eDepth) result += "Depth | ";
-    if (value & ImageAspectFlagBits::eStencil) result += "Stencil | ";
-    if (value & ImageAspectFlagBits::eMetadata) result += "Metadata | ";
-    if (value & ImageAspectFlagBits::ePlane0) result += "Plane0 | ";
-    if (value & ImageAspectFlagBits::ePlane1) result += "Plane1 | ";
-    if (value & ImageAspectFlagBits::ePlane2) result += "Plane2 | ";
-    if (value & ImageAspectFlagBits::eMemoryPlane0EXT) result += "MemoryPlane0EXT | ";
-    if (value & ImageAspectFlagBits::eMemoryPlane1EXT) result += "MemoryPlane1EXT | ";
-    if (value & ImageAspectFlagBits::eMemoryPlane2EXT) result += "MemoryPlane2EXT | ";
-    if (value & ImageAspectFlagBits::eMemoryPlane3EXT) result += "MemoryPlane3EXT | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlagBits value)
-  {
-    switch (value)
-    {
-    case SparseImageFormatFlagBits::eSingleMiptail: return "SingleMiptail";
-    case SparseImageFormatFlagBits::eAlignedMipSize: return "AlignedMipSize";
-    case SparseImageFormatFlagBits::eNonstandardBlockSize: return "NonstandardBlockSize";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SparseImageFormatFlagBits::eSingleMiptail) result += "SingleMiptail | ";
-    if (value & SparseImageFormatFlagBits::eAlignedMipSize) result += "AlignedMipSize | ";
-    if (value & SparseImageFormatFlagBits::eNonstandardBlockSize) result += "NonstandardBlockSize | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlagBits value)
-  {
-    switch (value)
-    {
-    case SparseMemoryBindFlagBits::eMetadata: return "Metadata";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SparseMemoryBindFlagBits::eMetadata) result += "Metadata | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineStageFlagBits value)
-  {
-    switch (value)
-    {
-    case PipelineStageFlagBits::eTopOfPipe: return "TopOfPipe";
-    case PipelineStageFlagBits::eDrawIndirect: return "DrawIndirect";
-    case PipelineStageFlagBits::eVertexInput: return "VertexInput";
-    case PipelineStageFlagBits::eVertexShader: return "VertexShader";
-    case PipelineStageFlagBits::eTessellationControlShader: return "TessellationControlShader";
-    case PipelineStageFlagBits::eTessellationEvaluationShader: return "TessellationEvaluationShader";
-    case PipelineStageFlagBits::eGeometryShader: return "GeometryShader";
-    case PipelineStageFlagBits::eFragmentShader: return "FragmentShader";
-    case PipelineStageFlagBits::eEarlyFragmentTests: return "EarlyFragmentTests";
-    case PipelineStageFlagBits::eLateFragmentTests: return "LateFragmentTests";
-    case PipelineStageFlagBits::eColorAttachmentOutput: return "ColorAttachmentOutput";
-    case PipelineStageFlagBits::eComputeShader: return "ComputeShader";
-    case PipelineStageFlagBits::eTransfer: return "Transfer";
-    case PipelineStageFlagBits::eBottomOfPipe: return "BottomOfPipe";
-    case PipelineStageFlagBits::eHost: return "Host";
-    case PipelineStageFlagBits::eAllGraphics: return "AllGraphics";
-    case PipelineStageFlagBits::eAllCommands: return "AllCommands";
-    case PipelineStageFlagBits::eTransformFeedbackEXT: return "TransformFeedbackEXT";
-    case PipelineStageFlagBits::eConditionalRenderingEXT: return "ConditionalRenderingEXT";
-    case PipelineStageFlagBits::eCommandProcessNVX: return "CommandProcessNVX";
-    case PipelineStageFlagBits::eShadingRateImageNV: return "ShadingRateImageNV";
-    case PipelineStageFlagBits::eRayTracingShaderNV: return "RayTracingShaderNV";
-    case PipelineStageFlagBits::eAccelerationStructureBuildNV: return "AccelerationStructureBuildNV";
-    case PipelineStageFlagBits::eTaskShaderNV: return "TaskShaderNV";
-    case PipelineStageFlagBits::eMeshShaderNV: return "MeshShaderNV";
-    case PipelineStageFlagBits::eFragmentDensityProcessEXT: return "FragmentDensityProcessEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineStageFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & PipelineStageFlagBits::eTopOfPipe) result += "TopOfPipe | ";
-    if (value & PipelineStageFlagBits::eDrawIndirect) result += "DrawIndirect | ";
-    if (value & PipelineStageFlagBits::eVertexInput) result += "VertexInput | ";
-    if (value & PipelineStageFlagBits::eVertexShader) result += "VertexShader | ";
-    if (value & PipelineStageFlagBits::eTessellationControlShader) result += "TessellationControlShader | ";
-    if (value & PipelineStageFlagBits::eTessellationEvaluationShader) result += "TessellationEvaluationShader | ";
-    if (value & PipelineStageFlagBits::eGeometryShader) result += "GeometryShader | ";
-    if (value & PipelineStageFlagBits::eFragmentShader) result += "FragmentShader | ";
-    if (value & PipelineStageFlagBits::eEarlyFragmentTests) result += "EarlyFragmentTests | ";
-    if (value & PipelineStageFlagBits::eLateFragmentTests) result += "LateFragmentTests | ";
-    if (value & PipelineStageFlagBits::eColorAttachmentOutput) result += "ColorAttachmentOutput | ";
-    if (value & PipelineStageFlagBits::eComputeShader) result += "ComputeShader | ";
-    if (value & PipelineStageFlagBits::eTransfer) result += "Transfer | ";
-    if (value & PipelineStageFlagBits::eBottomOfPipe) result += "BottomOfPipe | ";
-    if (value & PipelineStageFlagBits::eHost) result += "Host | ";
-    if (value & PipelineStageFlagBits::eAllGraphics) result += "AllGraphics | ";
-    if (value & PipelineStageFlagBits::eAllCommands) result += "AllCommands | ";
-    if (value & PipelineStageFlagBits::eTransformFeedbackEXT) result += "TransformFeedbackEXT | ";
-    if (value & PipelineStageFlagBits::eConditionalRenderingEXT) result += "ConditionalRenderingEXT | ";
-    if (value & PipelineStageFlagBits::eCommandProcessNVX) result += "CommandProcessNVX | ";
-    if (value & PipelineStageFlagBits::eShadingRateImageNV) result += "ShadingRateImageNV | ";
-    if (value & PipelineStageFlagBits::eRayTracingShaderNV) result += "RayTracingShaderNV | ";
-    if (value & PipelineStageFlagBits::eAccelerationStructureBuildNV) result += "AccelerationStructureBuildNV | ";
-    if (value & PipelineStageFlagBits::eTaskShaderNV) result += "TaskShaderNV | ";
-    if (value & PipelineStageFlagBits::eMeshShaderNV) result += "MeshShaderNV | ";
-    if (value & PipelineStageFlagBits::eFragmentDensityProcessEXT) result += "FragmentDensityProcessEXT | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case CommandPoolCreateFlagBits::eTransient: return "Transient";
-    case CommandPoolCreateFlagBits::eResetCommandBuffer: return "ResetCommandBuffer";
-    case CommandPoolCreateFlagBits::eProtected: return "Protected";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & CommandPoolCreateFlagBits::eTransient) result += "Transient | ";
-    if (value & CommandPoolCreateFlagBits::eResetCommandBuffer) result += "ResetCommandBuffer | ";
-    if (value & CommandPoolCreateFlagBits::eProtected) result += "Protected | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlagBits value)
-  {
-    switch (value)
-    {
-    case CommandPoolResetFlagBits::eReleaseResources: return "ReleaseResources";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & CommandPoolResetFlagBits::eReleaseResources) result += "ReleaseResources | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlagBits value)
-  {
-    switch (value)
-    {
-    case CommandBufferResetFlagBits::eReleaseResources: return "ReleaseResources";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & CommandBufferResetFlagBits::eReleaseResources) result += "ReleaseResources | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SampleCountFlagBits value)
-  {
-    switch (value)
-    {
-    case SampleCountFlagBits::e1: return "1";
-    case SampleCountFlagBits::e2: return "2";
-    case SampleCountFlagBits::e4: return "4";
-    case SampleCountFlagBits::e8: return "8";
-    case SampleCountFlagBits::e16: return "16";
-    case SampleCountFlagBits::e32: return "32";
-    case SampleCountFlagBits::e64: return "64";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SampleCountFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SampleCountFlagBits::e1) result += "1 | ";
-    if (value & SampleCountFlagBits::e2) result += "2 | ";
-    if (value & SampleCountFlagBits::e4) result += "4 | ";
-    if (value & SampleCountFlagBits::e8) result += "8 | ";
-    if (value & SampleCountFlagBits::e16) result += "16 | ";
-    if (value & SampleCountFlagBits::e32) result += "32 | ";
-    if (value & SampleCountFlagBits::e64) result += "64 | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlagBits value)
-  {
-    switch (value)
-    {
-    case AttachmentDescriptionFlagBits::eMayAlias: return "MayAlias";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & AttachmentDescriptionFlagBits::eMayAlias) result += "MayAlias | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(StencilFaceFlagBits value)
-  {
-    switch (value)
-    {
-    case StencilFaceFlagBits::eFront: return "Front";
-    case StencilFaceFlagBits::eBack: return "Back";
-    case StencilFaceFlagBits::eVkStencilFrontAndBack: return "VkStencilFrontAndBack";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(StencilFaceFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & StencilFaceFlagBits::eFront) result += "Front | ";
-    if (value & StencilFaceFlagBits::eBack) result += "Back | ";
-    if (value & StencilFaceFlagBits::eVkStencilFrontAndBack) result += "VkStencilFrontAndBack | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case DescriptorPoolCreateFlagBits::eFreeDescriptorSet: return "FreeDescriptorSet";
-    case DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT: return "UpdateAfterBindEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet) result += "FreeDescriptorSet | ";
-    if (value & DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT) result += "UpdateAfterBindEXT | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DependencyFlagBits value)
-  {
-    switch (value)
-    {
-    case DependencyFlagBits::eByRegion: return "ByRegion";
-    case DependencyFlagBits::eDeviceGroup: return "DeviceGroup";
-    case DependencyFlagBits::eViewLocal: return "ViewLocal";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DependencyFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DependencyFlagBits::eByRegion) result += "ByRegion | ";
-    if (value & DependencyFlagBits::eDeviceGroup) result += "DeviceGroup | ";
-    if (value & DependencyFlagBits::eViewLocal) result += "ViewLocal | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PresentModeKHR value)
-  {
-    switch (value)
-    {
-    case PresentModeKHR::eImmediate: return "Immediate";
-    case PresentModeKHR::eMailbox: return "Mailbox";
-    case PresentModeKHR::eFifo: return "Fifo";
-    case PresentModeKHR::eFifoRelaxed: return "FifoRelaxed";
-    case PresentModeKHR::eSharedDemandRefresh: return "SharedDemandRefresh";
-    case PresentModeKHR::eSharedContinuousRefresh: return "SharedContinuousRefresh";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ColorSpaceKHR value)
-  {
-    switch (value)
-    {
-    case ColorSpaceKHR::eSrgbNonlinear: return "SrgbNonlinear";
-    case ColorSpaceKHR::eDisplayP3NonlinearEXT: return "DisplayP3NonlinearEXT";
-    case ColorSpaceKHR::eExtendedSrgbLinearEXT: return "ExtendedSrgbLinearEXT";
-    case ColorSpaceKHR::eDciP3LinearEXT: return "DciP3LinearEXT";
-    case ColorSpaceKHR::eDciP3NonlinearEXT: return "DciP3NonlinearEXT";
-    case ColorSpaceKHR::eBt709LinearEXT: return "Bt709LinearEXT";
-    case ColorSpaceKHR::eBt709NonlinearEXT: return "Bt709NonlinearEXT";
-    case ColorSpaceKHR::eBt2020LinearEXT: return "Bt2020LinearEXT";
-    case ColorSpaceKHR::eHdr10St2084EXT: return "Hdr10St2084EXT";
-    case ColorSpaceKHR::eDolbyvisionEXT: return "DolbyvisionEXT";
-    case ColorSpaceKHR::eHdr10HlgEXT: return "Hdr10HlgEXT";
-    case ColorSpaceKHR::eAdobergbLinearEXT: return "AdobergbLinearEXT";
-    case ColorSpaceKHR::eAdobergbNonlinearEXT: return "AdobergbNonlinearEXT";
-    case ColorSpaceKHR::ePassThroughEXT: return "PassThroughEXT";
-    case ColorSpaceKHR::eExtendedSrgbNonlinearEXT: return "ExtendedSrgbNonlinearEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case DisplayPlaneAlphaFlagBitsKHR::eOpaque: return "Opaque";
-    case DisplayPlaneAlphaFlagBitsKHR::eGlobal: return "Global";
-    case DisplayPlaneAlphaFlagBitsKHR::ePerPixel: return "PerPixel";
-    case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied: return "PerPixelPremultiplied";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DisplayPlaneAlphaFlagBitsKHR::eOpaque) result += "Opaque | ";
-    if (value & DisplayPlaneAlphaFlagBitsKHR::eGlobal) result += "Global | ";
-    if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel) result += "PerPixel | ";
-    if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied) result += "PerPixelPremultiplied | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case CompositeAlphaFlagBitsKHR::eOpaque: return "Opaque";
-    case CompositeAlphaFlagBitsKHR::ePreMultiplied: return "PreMultiplied";
-    case CompositeAlphaFlagBitsKHR::ePostMultiplied: return "PostMultiplied";
-    case CompositeAlphaFlagBitsKHR::eInherit: return "Inherit";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & CompositeAlphaFlagBitsKHR::eOpaque) result += "Opaque | ";
-    if (value & CompositeAlphaFlagBitsKHR::ePreMultiplied) result += "PreMultiplied | ";
-    if (value & CompositeAlphaFlagBitsKHR::ePostMultiplied) result += "PostMultiplied | ";
-    if (value & CompositeAlphaFlagBitsKHR::eInherit) result += "Inherit | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SurfaceTransformFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case SurfaceTransformFlagBitsKHR::eIdentity: return "Identity";
-    case SurfaceTransformFlagBitsKHR::eRotate90: return "Rotate90";
-    case SurfaceTransformFlagBitsKHR::eRotate180: return "Rotate180";
-    case SurfaceTransformFlagBitsKHR::eRotate270: return "Rotate270";
-    case SurfaceTransformFlagBitsKHR::eHorizontalMirror: return "HorizontalMirror";
-    case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90: return "HorizontalMirrorRotate90";
-    case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180: return "HorizontalMirrorRotate180";
-    case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270: return "HorizontalMirrorRotate270";
-    case SurfaceTransformFlagBitsKHR::eInherit: return "Inherit";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SurfaceTransformFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SurfaceTransformFlagBitsKHR::eIdentity) result += "Identity | ";
-    if (value & SurfaceTransformFlagBitsKHR::eRotate90) result += "Rotate90 | ";
-    if (value & SurfaceTransformFlagBitsKHR::eRotate180) result += "Rotate180 | ";
-    if (value & SurfaceTransformFlagBitsKHR::eRotate270) result += "Rotate270 | ";
-    if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirror) result += "HorizontalMirror | ";
-    if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) result += "HorizontalMirrorRotate90 | ";
-    if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) result += "HorizontalMirrorRotate180 | ";
-    if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) result += "HorizontalMirrorRotate270 | ";
-    if (value & SurfaceTransformFlagBitsKHR::eInherit) result += "Inherit | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(TimeDomainEXT value)
-  {
-    switch (value)
-    {
-    case TimeDomainEXT::eDevice: return "Device";
-    case TimeDomainEXT::eClockMonotonic: return "ClockMonotonic";
-    case TimeDomainEXT::eClockMonotonicRaw: return "ClockMonotonicRaw";
-    case TimeDomainEXT::eQueryPerformanceCounter: return "QueryPerformanceCounter";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugReportFlagBitsEXT value)
-  {
-    switch (value)
-    {
-    case DebugReportFlagBitsEXT::eInformation: return "Information";
-    case DebugReportFlagBitsEXT::eWarning: return "Warning";
-    case DebugReportFlagBitsEXT::ePerformanceWarning: return "PerformanceWarning";
-    case DebugReportFlagBitsEXT::eError: return "Error";
-    case DebugReportFlagBitsEXT::eDebug: return "Debug";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugReportFlagsEXT value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DebugReportFlagBitsEXT::eInformation) result += "Information | ";
-    if (value & DebugReportFlagBitsEXT::eWarning) result += "Warning | ";
-    if (value & DebugReportFlagBitsEXT::ePerformanceWarning) result += "PerformanceWarning | ";
-    if (value & DebugReportFlagBitsEXT::eError) result += "Error | ";
-    if (value & DebugReportFlagBitsEXT::eDebug) result += "Debug | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugReportObjectTypeEXT value)
-  {
-    switch (value)
-    {
-    case DebugReportObjectTypeEXT::eUnknown: return "Unknown";
-    case DebugReportObjectTypeEXT::eInstance: return "Instance";
-    case DebugReportObjectTypeEXT::ePhysicalDevice: return "PhysicalDevice";
-    case DebugReportObjectTypeEXT::eDevice: return "Device";
-    case DebugReportObjectTypeEXT::eQueue: return "Queue";
-    case DebugReportObjectTypeEXT::eSemaphore: return "Semaphore";
-    case DebugReportObjectTypeEXT::eCommandBuffer: return "CommandBuffer";
-    case DebugReportObjectTypeEXT::eFence: return "Fence";
-    case DebugReportObjectTypeEXT::eDeviceMemory: return "DeviceMemory";
-    case DebugReportObjectTypeEXT::eBuffer: return "Buffer";
-    case DebugReportObjectTypeEXT::eImage: return "Image";
-    case DebugReportObjectTypeEXT::eEvent: return "Event";
-    case DebugReportObjectTypeEXT::eQueryPool: return "QueryPool";
-    case DebugReportObjectTypeEXT::eBufferView: return "BufferView";
-    case DebugReportObjectTypeEXT::eImageView: return "ImageView";
-    case DebugReportObjectTypeEXT::eShaderModule: return "ShaderModule";
-    case DebugReportObjectTypeEXT::ePipelineCache: return "PipelineCache";
-    case DebugReportObjectTypeEXT::ePipelineLayout: return "PipelineLayout";
-    case DebugReportObjectTypeEXT::eRenderPass: return "RenderPass";
-    case DebugReportObjectTypeEXT::ePipeline: return "Pipeline";
-    case DebugReportObjectTypeEXT::eDescriptorSetLayout: return "DescriptorSetLayout";
-    case DebugReportObjectTypeEXT::eSampler: return "Sampler";
-    case DebugReportObjectTypeEXT::eDescriptorPool: return "DescriptorPool";
-    case DebugReportObjectTypeEXT::eDescriptorSet: return "DescriptorSet";
-    case DebugReportObjectTypeEXT::eFramebuffer: return "Framebuffer";
-    case DebugReportObjectTypeEXT::eCommandPool: return "CommandPool";
-    case DebugReportObjectTypeEXT::eSurfaceKhr: return "SurfaceKhr";
-    case DebugReportObjectTypeEXT::eSwapchainKhr: return "SwapchainKhr";
-    case DebugReportObjectTypeEXT::eDebugReportCallbackExt: return "DebugReportCallbackExt";
-    case DebugReportObjectTypeEXT::eDisplayKhr: return "DisplayKhr";
-    case DebugReportObjectTypeEXT::eDisplayModeKhr: return "DisplayModeKhr";
-    case DebugReportObjectTypeEXT::eObjectTableNvx: return "ObjectTableNvx";
-    case DebugReportObjectTypeEXT::eIndirectCommandsLayoutNvx: return "IndirectCommandsLayoutNvx";
-    case DebugReportObjectTypeEXT::eValidationCacheExt: return "ValidationCacheExt";
-    case DebugReportObjectTypeEXT::eSamplerYcbcrConversion: return "SamplerYcbcrConversion";
-    case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate";
-    case DebugReportObjectTypeEXT::eAccelerationStructureNV: return "AccelerationStructureNV";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(RasterizationOrderAMD value)
-  {
-    switch (value)
-    {
-    case RasterizationOrderAMD::eStrict: return "Strict";
-    case RasterizationOrderAMD::eRelaxed: return "Relaxed";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBitsNV value)
-  {
-    switch (value)
-    {
-    case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32: return "OpaqueWin32";
-    case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
-    case ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image: return "D3D11Image";
-    case ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt: return "D3D11ImageKmt";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsNV value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) result += "OpaqueWin32 | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) result += "D3D11Image | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt) result += "D3D11ImageKmt | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsNV value)
-  {
-    switch (value)
-    {
-    case ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly: return "DedicatedOnly";
-    case ExternalMemoryFeatureFlagBitsNV::eExportable: return "Exportable";
-    case ExternalMemoryFeatureFlagBitsNV::eImportable: return "Importable";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsNV value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) result += "DedicatedOnly | ";
-    if (value & ExternalMemoryFeatureFlagBitsNV::eExportable) result += "Exportable | ";
-    if (value & ExternalMemoryFeatureFlagBitsNV::eImportable) result += "Importable | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ValidationCheckEXT value)
-  {
-    switch (value)
-    {
-    case ValidationCheckEXT::eAll: return "All";
-    case ValidationCheckEXT::eShaders: return "Shaders";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SubgroupFeatureFlagBits value)
-  {
-    switch (value)
-    {
-    case SubgroupFeatureFlagBits::eBasic: return "Basic";
-    case SubgroupFeatureFlagBits::eVote: return "Vote";
-    case SubgroupFeatureFlagBits::eArithmetic: return "Arithmetic";
-    case SubgroupFeatureFlagBits::eBallot: return "Ballot";
-    case SubgroupFeatureFlagBits::eShuffle: return "Shuffle";
-    case SubgroupFeatureFlagBits::eShuffleRelative: return "ShuffleRelative";
-    case SubgroupFeatureFlagBits::eClustered: return "Clustered";
-    case SubgroupFeatureFlagBits::eQuad: return "Quad";
-    case SubgroupFeatureFlagBits::ePartitionedNV: return "PartitionedNV";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SubgroupFeatureFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SubgroupFeatureFlagBits::eBasic) result += "Basic | ";
-    if (value & SubgroupFeatureFlagBits::eVote) result += "Vote | ";
-    if (value & SubgroupFeatureFlagBits::eArithmetic) result += "Arithmetic | ";
-    if (value & SubgroupFeatureFlagBits::eBallot) result += "Ballot | ";
-    if (value & SubgroupFeatureFlagBits::eShuffle) result += "Shuffle | ";
-    if (value & SubgroupFeatureFlagBits::eShuffleRelative) result += "ShuffleRelative | ";
-    if (value & SubgroupFeatureFlagBits::eClustered) result += "Clustered | ";
-    if (value & SubgroupFeatureFlagBits::eQuad) result += "Quad | ";
-    if (value & SubgroupFeatureFlagBits::ePartitionedNV) result += "PartitionedNV | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(IndirectCommandsLayoutUsageFlagBitsNVX value)
-  {
-    switch (value)
-    {
-    case IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences: return "UnorderedSequences";
-    case IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences: return "SparseSequences";
-    case IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions: return "EmptyExecutions";
-    case IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences: return "IndexedSequences";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(IndirectCommandsLayoutUsageFlagsNVX value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) result += "UnorderedSequences | ";
-    if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) result += "SparseSequences | ";
-    if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) result += "EmptyExecutions | ";
-    if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences) result += "IndexedSequences | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ObjectEntryUsageFlagBitsNVX value)
-  {
-    switch (value)
-    {
-    case ObjectEntryUsageFlagBitsNVX::eGraphics: return "Graphics";
-    case ObjectEntryUsageFlagBitsNVX::eCompute: return "Compute";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ObjectEntryUsageFlagsNVX value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ObjectEntryUsageFlagBitsNVX::eGraphics) result += "Graphics | ";
-    if (value & ObjectEntryUsageFlagBitsNVX::eCompute) result += "Compute | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(IndirectCommandsTokenTypeNVX value)
-  {
-    switch (value)
-    {
-    case IndirectCommandsTokenTypeNVX::ePipeline: return "Pipeline";
-    case IndirectCommandsTokenTypeNVX::eDescriptorSet: return "DescriptorSet";
-    case IndirectCommandsTokenTypeNVX::eIndexBuffer: return "IndexBuffer";
-    case IndirectCommandsTokenTypeNVX::eVertexBuffer: return "VertexBuffer";
-    case IndirectCommandsTokenTypeNVX::ePushConstant: return "PushConstant";
-    case IndirectCommandsTokenTypeNVX::eDrawIndexed: return "DrawIndexed";
-    case IndirectCommandsTokenTypeNVX::eDraw: return "Draw";
-    case IndirectCommandsTokenTypeNVX::eDispatch: return "Dispatch";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ObjectEntryTypeNVX value)
-  {
-    switch (value)
-    {
-    case ObjectEntryTypeNVX::eDescriptorSet: return "DescriptorSet";
-    case ObjectEntryTypeNVX::ePipeline: return "Pipeline";
-    case ObjectEntryTypeNVX::eIndexBuffer: return "IndexBuffer";
-    case ObjectEntryTypeNVX::eVertexBuffer: return "VertexBuffer";
-    case ObjectEntryTypeNVX::ePushConstant: return "PushConstant";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR: return "PushDescriptorKHR";
-    case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT: return "UpdateAfterBindPoolEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) result += "PushDescriptorKHR | ";
-    if (value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT) result += "UpdateAfterBindPoolEXT | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBits value)
-  {
-    switch (value)
-    {
-    case ExternalMemoryHandleTypeFlagBits::eOpaqueFd: return "OpaqueFd";
-    case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32: return "OpaqueWin32";
-    case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
-    case ExternalMemoryHandleTypeFlagBits::eD3D11Texture: return "D3D11Texture";
-    case ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt: return "D3D11TextureKmt";
-    case ExternalMemoryHandleTypeFlagBits::eD3D12Heap: return "D3D12Heap";
-    case ExternalMemoryHandleTypeFlagBits::eD3D12Resource: return "D3D12Resource";
-    case ExternalMemoryHandleTypeFlagBits::eDmaBufEXT: return "DmaBufEXT";
-    case ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID: return "AndroidHardwareBufferANDROID";
-    case ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT: return "HostAllocationEXT";
-    case ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT: return "HostMappedForeignMemoryEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueFd) result += "OpaqueFd | ";
-    if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32) result += "OpaqueWin32 | ";
-    if (value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | ";
-    if (value & ExternalMemoryHandleTypeFlagBits::eD3D11Texture) result += "D3D11Texture | ";
-    if (value & ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt) result += "D3D11TextureKmt | ";
-    if (value & ExternalMemoryHandleTypeFlagBits::eD3D12Heap) result += "D3D12Heap | ";
-    if (value & ExternalMemoryHandleTypeFlagBits::eD3D12Resource) result += "D3D12Resource | ";
-    if (value & ExternalMemoryHandleTypeFlagBits::eDmaBufEXT) result += "DmaBufEXT | ";
-    if (value & ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID) result += "AndroidHardwareBufferANDROID | ";
-    if (value & ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT) result += "HostAllocationEXT | ";
-    if (value & ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT) result += "HostMappedForeignMemoryEXT | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBits value)
-  {
-    switch (value)
-    {
-    case ExternalMemoryFeatureFlagBits::eDedicatedOnly: return "DedicatedOnly";
-    case ExternalMemoryFeatureFlagBits::eExportable: return "Exportable";
-    case ExternalMemoryFeatureFlagBits::eImportable: return "Importable";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalMemoryFeatureFlagBits::eDedicatedOnly) result += "DedicatedOnly | ";
-    if (value & ExternalMemoryFeatureFlagBits::eExportable) result += "Exportable | ";
-    if (value & ExternalMemoryFeatureFlagBits::eImportable) result += "Importable | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagBits value)
-  {
-    switch (value)
-    {
-    case ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd: return "OpaqueFd";
-    case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32: return "OpaqueWin32";
-    case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
-    case ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence: return "D3D12Fence";
-    case ExternalSemaphoreHandleTypeFlagBits::eSyncFd: return "SyncFd";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd) result += "OpaqueFd | ";
-    if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32) result += "OpaqueWin32 | ";
-    if (value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | ";
-    if (value & ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence) result += "D3D12Fence | ";
-    if (value & ExternalSemaphoreHandleTypeFlagBits::eSyncFd) result += "SyncFd | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagBits value)
-  {
-    switch (value)
-    {
-    case ExternalSemaphoreFeatureFlagBits::eExportable: return "Exportable";
-    case ExternalSemaphoreFeatureFlagBits::eImportable: return "Importable";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalSemaphoreFeatureFlagBits::eExportable) result += "Exportable | ";
-    if (value & ExternalSemaphoreFeatureFlagBits::eImportable) result += "Importable | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlagBits value)
-  {
-    switch (value)
-    {
-    case SemaphoreImportFlagBits::eTemporary: return "Temporary";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SemaphoreImportFlagBits::eTemporary) result += "Temporary | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlagBits value)
-  {
-    switch (value)
-    {
-    case ExternalFenceHandleTypeFlagBits::eOpaqueFd: return "OpaqueFd";
-    case ExternalFenceHandleTypeFlagBits::eOpaqueWin32: return "OpaqueWin32";
-    case ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
-    case ExternalFenceHandleTypeFlagBits::eSyncFd: return "SyncFd";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalFenceHandleTypeFlagBits::eOpaqueFd) result += "OpaqueFd | ";
-    if (value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32) result += "OpaqueWin32 | ";
-    if (value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | ";
-    if (value & ExternalFenceHandleTypeFlagBits::eSyncFd) result += "SyncFd | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlagBits value)
-  {
-    switch (value)
-    {
-    case ExternalFenceFeatureFlagBits::eExportable: return "Exportable";
-    case ExternalFenceFeatureFlagBits::eImportable: return "Importable";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalFenceFeatureFlagBits::eExportable) result += "Exportable | ";
-    if (value & ExternalFenceFeatureFlagBits::eImportable) result += "Importable | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FenceImportFlagBits value)
-  {
-    switch (value)
-    {
-    case FenceImportFlagBits::eTemporary: return "Temporary";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FenceImportFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & FenceImportFlagBits::eTemporary) result += "Temporary | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagBitsEXT value)
-  {
-    switch (value)
-    {
-    case SurfaceCounterFlagBitsEXT::eVblank: return "Vblank";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagsEXT value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SurfaceCounterFlagBitsEXT::eVblank) result += "Vblank | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplayPowerStateEXT value)
-  {
-    switch (value)
-    {
-    case DisplayPowerStateEXT::eOff: return "Off";
-    case DisplayPowerStateEXT::eSuspend: return "Suspend";
-    case DisplayPowerStateEXT::eOn: return "On";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceEventTypeEXT value)
-  {
-    switch (value)
-    {
-    case DeviceEventTypeEXT::eDisplayHotplug: return "DisplayHotplug";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplayEventTypeEXT value)
-  {
-    switch (value)
-    {
-    case DisplayEventTypeEXT::eFirstPixelOut: return "FirstPixelOut";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlagBits value)
-  {
-    switch (value)
-    {
-    case PeerMemoryFeatureFlagBits::eCopySrc: return "CopySrc";
-    case PeerMemoryFeatureFlagBits::eCopyDst: return "CopyDst";
-    case PeerMemoryFeatureFlagBits::eGenericSrc: return "GenericSrc";
-    case PeerMemoryFeatureFlagBits::eGenericDst: return "GenericDst";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & PeerMemoryFeatureFlagBits::eCopySrc) result += "CopySrc | ";
-    if (value & PeerMemoryFeatureFlagBits::eCopyDst) result += "CopyDst | ";
-    if (value & PeerMemoryFeatureFlagBits::eGenericSrc) result += "GenericSrc | ";
-    if (value & PeerMemoryFeatureFlagBits::eGenericDst) result += "GenericDst | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlagBits value)
-  {
-    switch (value)
-    {
-    case MemoryAllocateFlagBits::eDeviceMask: return "DeviceMask";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & MemoryAllocateFlagBits::eDeviceMask) result += "DeviceMask | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case DeviceGroupPresentModeFlagBitsKHR::eLocal: return "Local";
-    case DeviceGroupPresentModeFlagBitsKHR::eRemote: return "Remote";
-    case DeviceGroupPresentModeFlagBitsKHR::eSum: return "Sum";
-    case DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice: return "LocalMultiDevice";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DeviceGroupPresentModeFlagBitsKHR::eLocal) result += "Local | ";
-    if (value & DeviceGroupPresentModeFlagBitsKHR::eRemote) result += "Remote | ";
-    if (value & DeviceGroupPresentModeFlagBitsKHR::eSum) result += "Sum | ";
-    if (value & DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice) result += "LocalMultiDevice | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions: return "SplitInstanceBindRegions";
-    case SwapchainCreateFlagBitsKHR::eProtected: return "Protected";
-    case SwapchainCreateFlagBitsKHR::eMutableFormat: return "MutableFormat";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) result += "SplitInstanceBindRegions | ";
-    if (value & SwapchainCreateFlagBitsKHR::eProtected) result += "Protected | ";
-    if (value & SwapchainCreateFlagBitsKHR::eMutableFormat) result += "MutableFormat | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ViewportCoordinateSwizzleNV value)
-  {
-    switch (value)
-    {
-    case ViewportCoordinateSwizzleNV::ePositiveX: return "PositiveX";
-    case ViewportCoordinateSwizzleNV::eNegativeX: return "NegativeX";
-    case ViewportCoordinateSwizzleNV::ePositiveY: return "PositiveY";
-    case ViewportCoordinateSwizzleNV::eNegativeY: return "NegativeY";
-    case ViewportCoordinateSwizzleNV::ePositiveZ: return "PositiveZ";
-    case ViewportCoordinateSwizzleNV::eNegativeZ: return "NegativeZ";
-    case ViewportCoordinateSwizzleNV::ePositiveW: return "PositiveW";
-    case ViewportCoordinateSwizzleNV::eNegativeW: return "NegativeW";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DiscardRectangleModeEXT value)
-  {
-    switch (value)
-    {
-    case DiscardRectangleModeEXT::eInclusive: return "Inclusive";
-    case DiscardRectangleModeEXT::eExclusive: return "Exclusive";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlagBits value)
-  {
-    switch (value)
-    {
-    case SubpassDescriptionFlagBits::ePerViewAttributesNVX: return "PerViewAttributesNVX";
-    case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX: return "PerViewPositionXOnlyNVX";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SubpassDescriptionFlagBits::ePerViewAttributesNVX) result += "PerViewAttributesNVX | ";
-    if (value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) result += "PerViewPositionXOnlyNVX | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PointClippingBehavior value)
-  {
-    switch (value)
-    {
-    case PointClippingBehavior::eAllClipPlanes: return "AllClipPlanes";
-    case PointClippingBehavior::eUserClipPlanesOnly: return "UserClipPlanesOnly";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerReductionModeEXT value)
-  {
-    switch (value)
-    {
-    case SamplerReductionModeEXT::eWeightedAverage: return "WeightedAverage";
-    case SamplerReductionModeEXT::eMin: return "Min";
-    case SamplerReductionModeEXT::eMax: return "Max";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(TessellationDomainOrigin value)
-  {
-    switch (value)
-    {
-    case TessellationDomainOrigin::eUpperLeft: return "UpperLeft";
-    case TessellationDomainOrigin::eLowerLeft: return "LowerLeft";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrModelConversion value)
-  {
-    switch (value)
-    {
-    case SamplerYcbcrModelConversion::eRgbIdentity: return "RgbIdentity";
-    case SamplerYcbcrModelConversion::eYcbcrIdentity: return "YcbcrIdentity";
-    case SamplerYcbcrModelConversion::eYcbcr709: return "Ycbcr709";
-    case SamplerYcbcrModelConversion::eYcbcr601: return "Ycbcr601";
-    case SamplerYcbcrModelConversion::eYcbcr2020: return "Ycbcr2020";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrRange value)
-  {
-    switch (value)
-    {
-    case SamplerYcbcrRange::eItuFull: return "ItuFull";
-    case SamplerYcbcrRange::eItuNarrow: return "ItuNarrow";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ChromaLocation value)
-  {
-    switch (value)
-    {
-    case ChromaLocation::eCositedEven: return "CositedEven";
-    case ChromaLocation::eMidpoint: return "Midpoint";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BlendOverlapEXT value)
-  {
-    switch (value)
-    {
-    case BlendOverlapEXT::eUncorrelated: return "Uncorrelated";
-    case BlendOverlapEXT::eDisjoint: return "Disjoint";
-    case BlendOverlapEXT::eConjoint: return "Conjoint";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CoverageModulationModeNV value)
-  {
-    switch (value)
-    {
-    case CoverageModulationModeNV::eNone: return "None";
-    case CoverageModulationModeNV::eRgb: return "Rgb";
-    case CoverageModulationModeNV::eAlpha: return "Alpha";
-    case CoverageModulationModeNV::eRgba: return "Rgba";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ValidationCacheHeaderVersionEXT value)
-  {
-    switch (value)
-    {
-    case ValidationCacheHeaderVersionEXT::eOne: return "One";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ShaderInfoTypeAMD value)
-  {
-    switch (value)
-    {
-    case ShaderInfoTypeAMD::eStatistics: return "Statistics";
-    case ShaderInfoTypeAMD::eBinary: return "Binary";
-    case ShaderInfoTypeAMD::eDisassembly: return "Disassembly";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueueGlobalPriorityEXT value)
-  {
-    switch (value)
-    {
-    case QueueGlobalPriorityEXT::eLow: return "Low";
-    case QueueGlobalPriorityEXT::eMedium: return "Medium";
-    case QueueGlobalPriorityEXT::eHigh: return "High";
-    case QueueGlobalPriorityEXT::eRealtime: return "Realtime";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageSeverityFlagBitsEXT value)
-  {
-    switch (value)
-    {
-    case DebugUtilsMessageSeverityFlagBitsEXT::eVerbose: return "Verbose";
-    case DebugUtilsMessageSeverityFlagBitsEXT::eInfo: return "Info";
-    case DebugUtilsMessageSeverityFlagBitsEXT::eWarning: return "Warning";
-    case DebugUtilsMessageSeverityFlagBitsEXT::eError: return "Error";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageSeverityFlagsEXT value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DebugUtilsMessageSeverityFlagBitsEXT::eVerbose) result += "Verbose | ";
-    if (value & DebugUtilsMessageSeverityFlagBitsEXT::eInfo) result += "Info | ";
-    if (value & DebugUtilsMessageSeverityFlagBitsEXT::eWarning) result += "Warning | ";
-    if (value & DebugUtilsMessageSeverityFlagBitsEXT::eError) result += "Error | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageTypeFlagBitsEXT value)
-  {
-    switch (value)
-    {
-    case DebugUtilsMessageTypeFlagBitsEXT::eGeneral: return "General";
-    case DebugUtilsMessageTypeFlagBitsEXT::eValidation: return "Validation";
-    case DebugUtilsMessageTypeFlagBitsEXT::ePerformance: return "Performance";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugUtilsMessageTypeFlagsEXT value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DebugUtilsMessageTypeFlagBitsEXT::eGeneral) result += "General | ";
-    if (value & DebugUtilsMessageTypeFlagBitsEXT::eValidation) result += "Validation | ";
-    if (value & DebugUtilsMessageTypeFlagBitsEXT::ePerformance) result += "Performance | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ConservativeRasterizationModeEXT value)
-  {
-    switch (value)
-    {
-    case ConservativeRasterizationModeEXT::eDisabled: return "Disabled";
-    case ConservativeRasterizationModeEXT::eOverestimate: return "Overestimate";
-    case ConservativeRasterizationModeEXT::eUnderestimate: return "Underestimate";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorBindingFlagBitsEXT value)
-  {
-    switch (value)
-    {
-    case DescriptorBindingFlagBitsEXT::eUpdateAfterBind: return "UpdateAfterBind";
-    case DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending: return "UpdateUnusedWhilePending";
-    case DescriptorBindingFlagBitsEXT::ePartiallyBound: return "PartiallyBound";
-    case DescriptorBindingFlagBitsEXT::eVariableDescriptorCount: return "VariableDescriptorCount";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorBindingFlagsEXT value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DescriptorBindingFlagBitsEXT::eUpdateAfterBind) result += "UpdateAfterBind | ";
-    if (value & DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending) result += "UpdateUnusedWhilePending | ";
-    if (value & DescriptorBindingFlagBitsEXT::ePartiallyBound) result += "PartiallyBound | ";
-    if (value & DescriptorBindingFlagBitsEXT::eVariableDescriptorCount) result += "VariableDescriptorCount | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(VendorId value)
-  {
-    switch (value)
-    {
-    case VendorId::eViv: return "Viv";
-    case VendorId::eVsi: return "Vsi";
-    case VendorId::eKazan: return "Kazan";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DriverIdKHR value)
-  {
-    switch (value)
-    {
-    case DriverIdKHR::eAmdProprietary: return "AmdProprietary";
-    case DriverIdKHR::eAmdOpenSource: return "AmdOpenSource";
-    case DriverIdKHR::eMesaRadv: return "MesaRadv";
-    case DriverIdKHR::eNvidiaProprietary: return "NvidiaProprietary";
-    case DriverIdKHR::eIntelProprietaryWindows: return "IntelProprietaryWindows";
-    case DriverIdKHR::eIntelOpenSourceMesa: return "IntelOpenSourceMesa";
-    case DriverIdKHR::eImaginationProprietary: return "ImaginationProprietary";
-    case DriverIdKHR::eQualcommProprietary: return "QualcommProprietary";
-    case DriverIdKHR::eArmProprietary: return "ArmProprietary";
-    case DriverIdKHR::eGooglePastel: return "GooglePastel";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ConditionalRenderingFlagBitsEXT value)
-  {
-    switch (value)
-    {
-    case ConditionalRenderingFlagBitsEXT::eInverted: return "Inverted";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ConditionalRenderingFlagsEXT value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ConditionalRenderingFlagBitsEXT::eInverted) result += "Inverted | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ShadingRatePaletteEntryNV value)
-  {
-    switch (value)
-    {
-    case ShadingRatePaletteEntryNV::eNoInvocations: return "NoInvocations";
-    case ShadingRatePaletteEntryNV::e16InvocationsPerPixel: return "16InvocationsPerPixel";
-    case ShadingRatePaletteEntryNV::e8InvocationsPerPixel: return "8InvocationsPerPixel";
-    case ShadingRatePaletteEntryNV::e4InvocationsPerPixel: return "4InvocationsPerPixel";
-    case ShadingRatePaletteEntryNV::e2InvocationsPerPixel: return "2InvocationsPerPixel";
-    case ShadingRatePaletteEntryNV::e1InvocationPerPixel: return "1InvocationPerPixel";
-    case ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels: return "1InvocationPer2X1Pixels";
-    case ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels: return "1InvocationPer1X2Pixels";
-    case ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels: return "1InvocationPer2X2Pixels";
-    case ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels: return "1InvocationPer4X2Pixels";
-    case ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels: return "1InvocationPer2X4Pixels";
-    case ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels: return "1InvocationPer4X4Pixels";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CoarseSampleOrderTypeNV value)
-  {
-    switch (value)
-    {
-    case CoarseSampleOrderTypeNV::eDefault: return "Default";
-    case CoarseSampleOrderTypeNV::eCustom: return "Custom";
-    case CoarseSampleOrderTypeNV::ePixelMajor: return "PixelMajor";
-    case CoarseSampleOrderTypeNV::eSampleMajor: return "SampleMajor";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagBitsNV value)
-  {
-    switch (value)
-    {
-    case GeometryInstanceFlagBitsNV::eTriangleCullDisable: return "TriangleCullDisable";
-    case GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise: return "TriangleFrontCounterclockwise";
-    case GeometryInstanceFlagBitsNV::eForceOpaque: return "ForceOpaque";
-    case GeometryInstanceFlagBitsNV::eForceNoOpaque: return "ForceNoOpaque";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(GeometryInstanceFlagsNV value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & GeometryInstanceFlagBitsNV::eTriangleCullDisable) result += "TriangleCullDisable | ";
-    if (value & GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise) result += "TriangleFrontCounterclockwise | ";
-    if (value & GeometryInstanceFlagBitsNV::eForceOpaque) result += "ForceOpaque | ";
-    if (value & GeometryInstanceFlagBitsNV::eForceNoOpaque) result += "ForceNoOpaque | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(GeometryFlagBitsNV value)
-  {
-    switch (value)
-    {
-    case GeometryFlagBitsNV::eOpaque: return "Opaque";
-    case GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation: return "NoDuplicateAnyHitInvocation";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(GeometryFlagsNV value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & GeometryFlagBitsNV::eOpaque) result += "Opaque | ";
-    if (value & GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation) result += "NoDuplicateAnyHitInvocation | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BuildAccelerationStructureFlagBitsNV value)
-  {
-    switch (value)
-    {
-    case BuildAccelerationStructureFlagBitsNV::eAllowUpdate: return "AllowUpdate";
-    case BuildAccelerationStructureFlagBitsNV::eAllowCompaction: return "AllowCompaction";
-    case BuildAccelerationStructureFlagBitsNV::ePreferFastTrace: return "PreferFastTrace";
-    case BuildAccelerationStructureFlagBitsNV::ePreferFastBuild: return "PreferFastBuild";
-    case BuildAccelerationStructureFlagBitsNV::eLowMemory: return "LowMemory";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BuildAccelerationStructureFlagsNV value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & BuildAccelerationStructureFlagBitsNV::eAllowUpdate) result += "AllowUpdate | ";
-    if (value & BuildAccelerationStructureFlagBitsNV::eAllowCompaction) result += "AllowCompaction | ";
-    if (value & BuildAccelerationStructureFlagBitsNV::ePreferFastTrace) result += "PreferFastTrace | ";
-    if (value & BuildAccelerationStructureFlagBitsNV::ePreferFastBuild) result += "PreferFastBuild | ";
-    if (value & BuildAccelerationStructureFlagBitsNV::eLowMemory) result += "LowMemory | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CopyAccelerationStructureModeNV value)
-  {
-    switch (value)
-    {
-    case CopyAccelerationStructureModeNV::eClone: return "Clone";
-    case CopyAccelerationStructureModeNV::eCompact: return "Compact";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AccelerationStructureTypeNV value)
-  {
-    switch (value)
-    {
-    case AccelerationStructureTypeNV::eTopLevel: return "TopLevel";
-    case AccelerationStructureTypeNV::eBottomLevel: return "BottomLevel";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(GeometryTypeNV value)
-  {
-    switch (value)
-    {
-    case GeometryTypeNV::eTriangles: return "Triangles";
-    case GeometryTypeNV::eAabbs: return "Aabbs";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AccelerationStructureMemoryRequirementsTypeNV value)
-  {
-    switch (value)
-    {
-    case AccelerationStructureMemoryRequirementsTypeNV::eObject: return "Object";
-    case AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch: return "BuildScratch";
-    case AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch: return "UpdateScratch";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(RayTracingShaderGroupTypeNV value)
-  {
-    switch (value)
-    {
-    case RayTracingShaderGroupTypeNV::eGeneral: return "General";
-    case RayTracingShaderGroupTypeNV::eTrianglesHitGroup: return "TrianglesHitGroup";
-    case RayTracingShaderGroupTypeNV::eProceduralHitGroup: return "ProceduralHitGroup";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryOverallocationBehaviorAMD value)
-  {
-    switch (value)
-    {
-    case MemoryOverallocationBehaviorAMD::eDefault: return "Default";
-    case MemoryOverallocationBehaviorAMD::eAllowed: return "Allowed";
-    case MemoryOverallocationBehaviorAMD::eDisallowed: return "Disallowed";
-    default: return "invalid";
-    }
-  }
+  template <> struct isStructureChainValid<WriteDescriptorSet, WriteDescriptorSetAccelerationStructureNV>{ enum { value = true }; };
+  template <> struct isStructureChainValid<WriteDescriptorSet, WriteDescriptorSetInlineUniformBlockEXT>{ enum { value = true }; };
 
   class DispatchLoaderDynamic
   {
   public:
-    PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0;
-    PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0;
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0;
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-    PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0;
-    PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0;
-    PFN_vkAllocateMemory vkAllocateMemory = 0;
+    PFN_vkCreateInstance vkCreateInstance = 0;
+    PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0;
+    PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0;
+    PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0;
     PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0;
-    PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0;
-    PFN_vkBindBufferMemory vkBindBufferMemory = 0;
-    PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0;
-    PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0;
-    PFN_vkBindImageMemory vkBindImageMemory = 0;
-    PFN_vkBindImageMemory2 vkBindImageMemory2 = 0;
-    PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0;
     PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0;
     PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0;
     PFN_vkCmdBeginQuery vkCmdBeginQuery = 0;
@@ -52867,41 +53153,37 @@ public:
     PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0;
     PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0;
     PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0;
+    PFN_vkEndCommandBuffer vkEndCommandBuffer = 0;
+    PFN_vkResetCommandBuffer vkResetCommandBuffer = 0;
+    PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0;
+    PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0;
+    PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0;
+    PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0;
+    PFN_vkAllocateMemory vkAllocateMemory = 0;
+    PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0;
+    PFN_vkBindBufferMemory vkBindBufferMemory = 0;
+    PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0;
+    PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0;
+    PFN_vkBindImageMemory vkBindImageMemory = 0;
+    PFN_vkBindImageMemory2 vkBindImageMemory2 = 0;
+    PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0;
     PFN_vkCompileDeferredNV vkCompileDeferredNV = 0;
     PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0;
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0;
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
     PFN_vkCreateBuffer vkCreateBuffer = 0;
     PFN_vkCreateBufferView vkCreateBufferView = 0;
     PFN_vkCreateCommandPool vkCreateCommandPool = 0;
     PFN_vkCreateComputePipelines vkCreateComputePipelines = 0;
-    PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0;
-    PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0;
     PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0;
     PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0;
     PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0;
     PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0;
-    PFN_vkCreateDevice vkCreateDevice = 0;
-    PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0;
-    PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0;
     PFN_vkCreateEvent vkCreateEvent = 0;
     PFN_vkCreateFence vkCreateFence = 0;
     PFN_vkCreateFramebuffer vkCreateFramebuffer = 0;
     PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0;
-#ifdef VK_USE_PLATFORM_IOS_MVK
-    PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0;
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
     PFN_vkCreateImage vkCreateImage = 0;
-#ifdef VK_USE_PLATFORM_FUCHSIA
-    PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0;
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
     PFN_vkCreateImageView vkCreateImageView = 0;
     PFN_vkCreateIndirectCommandsLayoutNVX vkCreateIndirectCommandsLayoutNVX = 0;
-    PFN_vkCreateInstance vkCreateInstance = 0;
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-    PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0;
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
     PFN_vkCreateObjectTableNVX vkCreateObjectTableNVX = 0;
     PFN_vkCreatePipelineCache vkCreatePipelineCache = 0;
     PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0;
@@ -52917,30 +53199,12 @@ public:
     PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0;
     PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0;
     PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0;
-#ifdef VK_USE_PLATFORM_VI_NN
-    PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0;
-#endif /*VK_USE_PLATFORM_VI_NN*/
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0;
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0;
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0;
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
     PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0;
     PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0;
-    PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0;
     PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0;
     PFN_vkDestroyBuffer vkDestroyBuffer = 0;
     PFN_vkDestroyBufferView vkDestroyBufferView = 0;
     PFN_vkDestroyCommandPool vkDestroyCommandPool = 0;
-    PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0;
-    PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0;
     PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0;
     PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0;
     PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0;
@@ -52952,7 +53216,6 @@ public:
     PFN_vkDestroyImage vkDestroyImage = 0;
     PFN_vkDestroyImageView vkDestroyImageView = 0;
     PFN_vkDestroyIndirectCommandsLayoutNVX vkDestroyIndirectCommandsLayoutNVX = 0;
-    PFN_vkDestroyInstance vkDestroyInstance = 0;
     PFN_vkDestroyObjectTableNVX vkDestroyObjectTableNVX = 0;
     PFN_vkDestroyPipeline vkDestroyPipeline = 0;
     PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0;
@@ -52964,20 +53227,10 @@ public:
     PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0;
     PFN_vkDestroySemaphore vkDestroySemaphore = 0;
     PFN_vkDestroyShaderModule vkDestroyShaderModule = 0;
-    PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0;
     PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0;
     PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0;
     PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0;
     PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0;
-    PFN_vkEndCommandBuffer vkEndCommandBuffer = 0;
-    PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0;
-    PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0;
-    PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0;
-    PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0;
-    PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0;
-    PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0;
-    PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0;
-    PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0;
     PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0;
     PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0;
     PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0;
@@ -53001,11 +53254,6 @@ public:
     PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0;
     PFN_vkGetDeviceQueue vkGetDeviceQueue = 0;
     PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0;
-    PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0;
-    PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0;
-    PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0;
-    PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0;
-    PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0;
     PFN_vkGetEventStatus vkGetEventStatus = 0;
     PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0;
     PFN_vkGetFenceStatus vkGetFenceStatus = 0;
@@ -53020,7 +53268,6 @@ public:
     PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0;
     PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0;
     PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0;
-    PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0;
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
     PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0;
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
@@ -53037,6 +53284,103 @@ public:
     PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0;
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
     PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0;
+    PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0;
+    PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0;
+    PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0;
+    PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0;
+    PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0;
+    PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+    PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0;
+    PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0;
+    PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0;
+    PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0;
+    PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0;
+    PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+    PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+    PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0;
+    PFN_vkMapMemory vkMapMemory = 0;
+    PFN_vkMergePipelineCaches vkMergePipelineCaches = 0;
+    PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0;
+    PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0;
+    PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0;
+    PFN_vkRegisterObjectsNVX vkRegisterObjectsNVX = 0;
+    PFN_vkResetCommandPool vkResetCommandPool = 0;
+    PFN_vkResetDescriptorPool vkResetDescriptorPool = 0;
+    PFN_vkResetEvent vkResetEvent = 0;
+    PFN_vkResetFences vkResetFences = 0;
+    PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0;
+    PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0;
+    PFN_vkSetEvent vkSetEvent = 0;
+    PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0;
+    PFN_vkTrimCommandPool vkTrimCommandPool = 0;
+    PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0;
+    PFN_vkUnmapMemory vkUnmapMemory = 0;
+    PFN_vkUnregisterObjectsNVX vkUnregisterObjectsNVX = 0;
+    PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0;
+    PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0;
+    PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0;
+    PFN_vkWaitForFences vkWaitForFences = 0;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0;
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+    PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0;
+    PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0;
+    PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0;
+#ifdef VK_USE_PLATFORM_IOS_MVK
+    PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0;
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+    PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0;
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+#ifdef VK_USE_PLATFORM_VI_NN
+    PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0;
+#endif /*VK_USE_PLATFORM_VI_NN*/
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0;
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0;
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0;
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+    PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0;
+    PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0;
+    PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0;
+    PFN_vkDestroyInstance vkDestroyInstance = 0;
+    PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0;
+    PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0;
+    PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0;
+    PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0;
+    PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0;
+    PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0;
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+    PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0;
+#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+    PFN_vkCreateDevice vkCreateDevice = 0;
+    PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0;
+    PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0;
+    PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0;
+    PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0;
+    PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0;
+    PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0;
+    PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0;
+    PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0;
     PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0;
     PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0;
     PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0;
@@ -53092,36 +53436,11 @@ public:
 #ifdef VK_USE_PLATFORM_XLIB_KHR
     PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0;
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
-    PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0;
-    PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0;
-    PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0;
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0;
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-    PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0;
-    PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0;
-    PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0;
-    PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0;
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0;
-    PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0;
-    PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0;
-    PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0;
-    PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0;
-    PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0;
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0;
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0;
-    PFN_vkMapMemory vkMapMemory = 0;
-    PFN_vkMergePipelineCaches vkMergePipelineCaches = 0;
-    PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0;
+    PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0;
+    PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0;
     PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0;
     PFN_vkQueueBindSparse vkQueueBindSparse = 0;
     PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0;
@@ -53129,28 +53448,6 @@ public:
     PFN_vkQueuePresentKHR vkQueuePresentKHR = 0;
     PFN_vkQueueSubmit vkQueueSubmit = 0;
     PFN_vkQueueWaitIdle vkQueueWaitIdle = 0;
-    PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0;
-    PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0;
-    PFN_vkRegisterObjectsNVX vkRegisterObjectsNVX = 0;
-    PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0;
-    PFN_vkResetCommandBuffer vkResetCommandBuffer = 0;
-    PFN_vkResetCommandPool vkResetCommandPool = 0;
-    PFN_vkResetDescriptorPool vkResetDescriptorPool = 0;
-    PFN_vkResetEvent vkResetEvent = 0;
-    PFN_vkResetFences vkResetFences = 0;
-    PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0;
-    PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0;
-    PFN_vkSetEvent vkSetEvent = 0;
-    PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0;
-    PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0;
-    PFN_vkTrimCommandPool vkTrimCommandPool = 0;
-    PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0;
-    PFN_vkUnmapMemory vkUnmapMemory = 0;
-    PFN_vkUnregisterObjectsNVX vkUnregisterObjectsNVX = 0;
-    PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0;
-    PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0;
-    PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0;
-    PFN_vkWaitForFences vkWaitForFences = 0;
   public:
     DispatchLoaderDynamic(Instance instance = Instance(), Device device = Device())
     {
@@ -53162,22 +53459,11 @@ public:
 
     void init(Instance instance, Device device = Device())
     {
-      vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR(device ? device.getProcAddr( "vkAcquireNextImage2KHR") : instance.getProcAddr( "vkAcquireNextImage2KHR"));
-      vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR(device ? device.getProcAddr( "vkAcquireNextImageKHR") : instance.getProcAddr( "vkAcquireNextImageKHR"));
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-      vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT(instance.getProcAddr( "vkAcquireXlibDisplayEXT"));
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-      vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers(device ? device.getProcAddr( "vkAllocateCommandBuffers") : instance.getProcAddr( "vkAllocateCommandBuffers"));
-      vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets(device ? device.getProcAddr( "vkAllocateDescriptorSets") : instance.getProcAddr( "vkAllocateDescriptorSets"));
-      vkAllocateMemory = PFN_vkAllocateMemory(device ? device.getProcAddr( "vkAllocateMemory") : instance.getProcAddr( "vkAllocateMemory"));
+      vkCreateInstance = PFN_vkCreateInstance(instance.getProcAddr( "vkCreateInstance"));
+      vkEnumerateInstanceExtensionProperties = PFN_vkEnumerateInstanceExtensionProperties(instance.getProcAddr( "vkEnumerateInstanceExtensionProperties"));
+      vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties(instance.getProcAddr( "vkEnumerateInstanceLayerProperties"));
+      vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion(instance.getProcAddr( "vkEnumerateInstanceVersion"));
       vkBeginCommandBuffer = PFN_vkBeginCommandBuffer(device ? device.getProcAddr( "vkBeginCommandBuffer") : instance.getProcAddr( "vkBeginCommandBuffer"));
-      vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV(device ? device.getProcAddr( "vkBindAccelerationStructureMemoryNV") : instance.getProcAddr( "vkBindAccelerationStructureMemoryNV"));
-      vkBindBufferMemory = PFN_vkBindBufferMemory(device ? device.getProcAddr( "vkBindBufferMemory") : instance.getProcAddr( "vkBindBufferMemory"));
-      vkBindBufferMemory2 = PFN_vkBindBufferMemory2(device ? device.getProcAddr( "vkBindBufferMemory2") : instance.getProcAddr( "vkBindBufferMemory2"));
-      vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(device ? device.getProcAddr( "vkBindBufferMemory2KHR") : instance.getProcAddr( "vkBindBufferMemory2KHR"));
-      vkBindImageMemory = PFN_vkBindImageMemory(device ? device.getProcAddr( "vkBindImageMemory") : instance.getProcAddr( "vkBindImageMemory"));
-      vkBindImageMemory2 = PFN_vkBindImageMemory2(device ? device.getProcAddr( "vkBindImageMemory2") : instance.getProcAddr( "vkBindImageMemory2"));
-      vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(device ? device.getProcAddr( "vkBindImageMemory2KHR") : instance.getProcAddr( "vkBindImageMemory2KHR"));
       vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT(device ? device.getProcAddr( "vkCmdBeginConditionalRenderingEXT") : instance.getProcAddr( "vkCmdBeginConditionalRenderingEXT"));
       vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdBeginDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdBeginDebugUtilsLabelEXT"));
       vkCmdBeginQuery = PFN_vkCmdBeginQuery(device ? device.getProcAddr( "vkCmdBeginQuery") : instance.getProcAddr( "vkCmdBeginQuery"));
@@ -53267,41 +53553,37 @@ public:
       vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV(device ? device.getProcAddr( "vkCmdWriteAccelerationStructuresPropertiesNV") : instance.getProcAddr( "vkCmdWriteAccelerationStructuresPropertiesNV"));
       vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD(device ? device.getProcAddr( "vkCmdWriteBufferMarkerAMD") : instance.getProcAddr( "vkCmdWriteBufferMarkerAMD"));
       vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp(device ? device.getProcAddr( "vkCmdWriteTimestamp") : instance.getProcAddr( "vkCmdWriteTimestamp"));
+      vkEndCommandBuffer = PFN_vkEndCommandBuffer(device ? device.getProcAddr( "vkEndCommandBuffer") : instance.getProcAddr( "vkEndCommandBuffer"));
+      vkResetCommandBuffer = PFN_vkResetCommandBuffer(device ? device.getProcAddr( "vkResetCommandBuffer") : instance.getProcAddr( "vkResetCommandBuffer"));
+      vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR(device ? device.getProcAddr( "vkAcquireNextImage2KHR") : instance.getProcAddr( "vkAcquireNextImage2KHR"));
+      vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR(device ? device.getProcAddr( "vkAcquireNextImageKHR") : instance.getProcAddr( "vkAcquireNextImageKHR"));
+      vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers(device ? device.getProcAddr( "vkAllocateCommandBuffers") : instance.getProcAddr( "vkAllocateCommandBuffers"));
+      vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets(device ? device.getProcAddr( "vkAllocateDescriptorSets") : instance.getProcAddr( "vkAllocateDescriptorSets"));
+      vkAllocateMemory = PFN_vkAllocateMemory(device ? device.getProcAddr( "vkAllocateMemory") : instance.getProcAddr( "vkAllocateMemory"));
+      vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV(device ? device.getProcAddr( "vkBindAccelerationStructureMemoryNV") : instance.getProcAddr( "vkBindAccelerationStructureMemoryNV"));
+      vkBindBufferMemory = PFN_vkBindBufferMemory(device ? device.getProcAddr( "vkBindBufferMemory") : instance.getProcAddr( "vkBindBufferMemory"));
+      vkBindBufferMemory2 = PFN_vkBindBufferMemory2(device ? device.getProcAddr( "vkBindBufferMemory2") : instance.getProcAddr( "vkBindBufferMemory2"));
+      vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(device ? device.getProcAddr( "vkBindBufferMemory2KHR") : instance.getProcAddr( "vkBindBufferMemory2KHR"));
+      vkBindImageMemory = PFN_vkBindImageMemory(device ? device.getProcAddr( "vkBindImageMemory") : instance.getProcAddr( "vkBindImageMemory"));
+      vkBindImageMemory2 = PFN_vkBindImageMemory2(device ? device.getProcAddr( "vkBindImageMemory2") : instance.getProcAddr( "vkBindImageMemory2"));
+      vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(device ? device.getProcAddr( "vkBindImageMemory2KHR") : instance.getProcAddr( "vkBindImageMemory2KHR"));
       vkCompileDeferredNV = PFN_vkCompileDeferredNV(device ? device.getProcAddr( "vkCompileDeferredNV") : instance.getProcAddr( "vkCompileDeferredNV"));
       vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV(device ? device.getProcAddr( "vkCreateAccelerationStructureNV") : instance.getProcAddr( "vkCreateAccelerationStructureNV"));
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-      vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR(instance.getProcAddr( "vkCreateAndroidSurfaceKHR"));
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
       vkCreateBuffer = PFN_vkCreateBuffer(device ? device.getProcAddr( "vkCreateBuffer") : instance.getProcAddr( "vkCreateBuffer"));
       vkCreateBufferView = PFN_vkCreateBufferView(device ? device.getProcAddr( "vkCreateBufferView") : instance.getProcAddr( "vkCreateBufferView"));
       vkCreateCommandPool = PFN_vkCreateCommandPool(device ? device.getProcAddr( "vkCreateCommandPool") : instance.getProcAddr( "vkCreateCommandPool"));
       vkCreateComputePipelines = PFN_vkCreateComputePipelines(device ? device.getProcAddr( "vkCreateComputePipelines") : instance.getProcAddr( "vkCreateComputePipelines"));
-      vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT(instance.getProcAddr( "vkCreateDebugReportCallbackEXT"));
-      vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT(instance.getProcAddr( "vkCreateDebugUtilsMessengerEXT"));
       vkCreateDescriptorPool = PFN_vkCreateDescriptorPool(device ? device.getProcAddr( "vkCreateDescriptorPool") : instance.getProcAddr( "vkCreateDescriptorPool"));
       vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout(device ? device.getProcAddr( "vkCreateDescriptorSetLayout") : instance.getProcAddr( "vkCreateDescriptorSetLayout"));
       vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(device ? device.getProcAddr( "vkCreateDescriptorUpdateTemplate") : instance.getProcAddr( "vkCreateDescriptorUpdateTemplate"));
       vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR(device ? device.getProcAddr( "vkCreateDescriptorUpdateTemplateKHR") : instance.getProcAddr( "vkCreateDescriptorUpdateTemplateKHR"));
-      vkCreateDevice = PFN_vkCreateDevice(instance.getProcAddr( "vkCreateDevice"));
-      vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR(instance.getProcAddr( "vkCreateDisplayModeKHR"));
-      vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR(instance.getProcAddr( "vkCreateDisplayPlaneSurfaceKHR"));
       vkCreateEvent = PFN_vkCreateEvent(device ? device.getProcAddr( "vkCreateEvent") : instance.getProcAddr( "vkCreateEvent"));
       vkCreateFence = PFN_vkCreateFence(device ? device.getProcAddr( "vkCreateFence") : instance.getProcAddr( "vkCreateFence"));
       vkCreateFramebuffer = PFN_vkCreateFramebuffer(device ? device.getProcAddr( "vkCreateFramebuffer") : instance.getProcAddr( "vkCreateFramebuffer"));
       vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines(device ? device.getProcAddr( "vkCreateGraphicsPipelines") : instance.getProcAddr( "vkCreateGraphicsPipelines"));
-#ifdef VK_USE_PLATFORM_IOS_MVK
-      vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK(instance.getProcAddr( "vkCreateIOSSurfaceMVK"));
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
       vkCreateImage = PFN_vkCreateImage(device ? device.getProcAddr( "vkCreateImage") : instance.getProcAddr( "vkCreateImage"));
-#ifdef VK_USE_PLATFORM_FUCHSIA
-      vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA(instance.getProcAddr( "vkCreateImagePipeSurfaceFUCHSIA"));
-#endif /*VK_USE_PLATFORM_FUCHSIA*/
       vkCreateImageView = PFN_vkCreateImageView(device ? device.getProcAddr( "vkCreateImageView") : instance.getProcAddr( "vkCreateImageView"));
       vkCreateIndirectCommandsLayoutNVX = PFN_vkCreateIndirectCommandsLayoutNVX(device ? device.getProcAddr( "vkCreateIndirectCommandsLayoutNVX") : instance.getProcAddr( "vkCreateIndirectCommandsLayoutNVX"));
-      vkCreateInstance = PFN_vkCreateInstance(instance.getProcAddr( "vkCreateInstance"));
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-      vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK(instance.getProcAddr( "vkCreateMacOSSurfaceMVK"));
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
       vkCreateObjectTableNVX = PFN_vkCreateObjectTableNVX(device ? device.getProcAddr( "vkCreateObjectTableNVX") : instance.getProcAddr( "vkCreateObjectTableNVX"));
       vkCreatePipelineCache = PFN_vkCreatePipelineCache(device ? device.getProcAddr( "vkCreatePipelineCache") : instance.getProcAddr( "vkCreatePipelineCache"));
       vkCreatePipelineLayout = PFN_vkCreatePipelineLayout(device ? device.getProcAddr( "vkCreatePipelineLayout") : instance.getProcAddr( "vkCreatePipelineLayout"));
@@ -53317,30 +53599,12 @@ public:
       vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR(device ? device.getProcAddr( "vkCreateSharedSwapchainsKHR") : instance.getProcAddr( "vkCreateSharedSwapchainsKHR"));
       vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR(device ? device.getProcAddr( "vkCreateSwapchainKHR") : instance.getProcAddr( "vkCreateSwapchainKHR"));
       vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT(device ? device.getProcAddr( "vkCreateValidationCacheEXT") : instance.getProcAddr( "vkCreateValidationCacheEXT"));
-#ifdef VK_USE_PLATFORM_VI_NN
-      vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN(instance.getProcAddr( "vkCreateViSurfaceNN"));
-#endif /*VK_USE_PLATFORM_VI_NN*/
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-      vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR(instance.getProcAddr( "vkCreateWaylandSurfaceKHR"));
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-      vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR(instance.getProcAddr( "vkCreateWin32SurfaceKHR"));
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_XCB_KHR
-      vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR(instance.getProcAddr( "vkCreateXcbSurfaceKHR"));
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-      vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR(instance.getProcAddr( "vkCreateXlibSurfaceKHR"));
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
       vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT(device ? device.getProcAddr( "vkDebugMarkerSetObjectNameEXT") : instance.getProcAddr( "vkDebugMarkerSetObjectNameEXT"));
       vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT(device ? device.getProcAddr( "vkDebugMarkerSetObjectTagEXT") : instance.getProcAddr( "vkDebugMarkerSetObjectTagEXT"));
-      vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT(instance.getProcAddr( "vkDebugReportMessageEXT"));
       vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV(device ? device.getProcAddr( "vkDestroyAccelerationStructureNV") : instance.getProcAddr( "vkDestroyAccelerationStructureNV"));
       vkDestroyBuffer = PFN_vkDestroyBuffer(device ? device.getProcAddr( "vkDestroyBuffer") : instance.getProcAddr( "vkDestroyBuffer"));
       vkDestroyBufferView = PFN_vkDestroyBufferView(device ? device.getProcAddr( "vkDestroyBufferView") : instance.getProcAddr( "vkDestroyBufferView"));
       vkDestroyCommandPool = PFN_vkDestroyCommandPool(device ? device.getProcAddr( "vkDestroyCommandPool") : instance.getProcAddr( "vkDestroyCommandPool"));
-      vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT(instance.getProcAddr( "vkDestroyDebugReportCallbackEXT"));
-      vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT(instance.getProcAddr( "vkDestroyDebugUtilsMessengerEXT"));
       vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool(device ? device.getProcAddr( "vkDestroyDescriptorPool") : instance.getProcAddr( "vkDestroyDescriptorPool"));
       vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout(device ? device.getProcAddr( "vkDestroyDescriptorSetLayout") : instance.getProcAddr( "vkDestroyDescriptorSetLayout"));
       vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate(device ? device.getProcAddr( "vkDestroyDescriptorUpdateTemplate") : instance.getProcAddr( "vkDestroyDescriptorUpdateTemplate"));
@@ -53352,7 +53616,6 @@ public:
       vkDestroyImage = PFN_vkDestroyImage(device ? device.getProcAddr( "vkDestroyImage") : instance.getProcAddr( "vkDestroyImage"));
       vkDestroyImageView = PFN_vkDestroyImageView(device ? device.getProcAddr( "vkDestroyImageView") : instance.getProcAddr( "vkDestroyImageView"));
       vkDestroyIndirectCommandsLayoutNVX = PFN_vkDestroyIndirectCommandsLayoutNVX(device ? device.getProcAddr( "vkDestroyIndirectCommandsLayoutNVX") : instance.getProcAddr( "vkDestroyIndirectCommandsLayoutNVX"));
-      vkDestroyInstance = PFN_vkDestroyInstance(instance.getProcAddr( "vkDestroyInstance"));
       vkDestroyObjectTableNVX = PFN_vkDestroyObjectTableNVX(device ? device.getProcAddr( "vkDestroyObjectTableNVX") : instance.getProcAddr( "vkDestroyObjectTableNVX"));
       vkDestroyPipeline = PFN_vkDestroyPipeline(device ? device.getProcAddr( "vkDestroyPipeline") : instance.getProcAddr( "vkDestroyPipeline"));
       vkDestroyPipelineCache = PFN_vkDestroyPipelineCache(device ? device.getProcAddr( "vkDestroyPipelineCache") : instance.getProcAddr( "vkDestroyPipelineCache"));
@@ -53364,20 +53627,10 @@ public:
       vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(device ? device.getProcAddr( "vkDestroySamplerYcbcrConversionKHR") : instance.getProcAddr( "vkDestroySamplerYcbcrConversionKHR"));
       vkDestroySemaphore = PFN_vkDestroySemaphore(device ? device.getProcAddr( "vkDestroySemaphore") : instance.getProcAddr( "vkDestroySemaphore"));
       vkDestroyShaderModule = PFN_vkDestroyShaderModule(device ? device.getProcAddr( "vkDestroyShaderModule") : instance.getProcAddr( "vkDestroyShaderModule"));
-      vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR(instance.getProcAddr( "vkDestroySurfaceKHR"));
       vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR(device ? device.getProcAddr( "vkDestroySwapchainKHR") : instance.getProcAddr( "vkDestroySwapchainKHR"));
       vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT(device ? device.getProcAddr( "vkDestroyValidationCacheEXT") : instance.getProcAddr( "vkDestroyValidationCacheEXT"));
       vkDeviceWaitIdle = PFN_vkDeviceWaitIdle(device ? device.getProcAddr( "vkDeviceWaitIdle") : instance.getProcAddr( "vkDeviceWaitIdle"));
       vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT(device ? device.getProcAddr( "vkDisplayPowerControlEXT") : instance.getProcAddr( "vkDisplayPowerControlEXT"));
-      vkEndCommandBuffer = PFN_vkEndCommandBuffer(device ? device.getProcAddr( "vkEndCommandBuffer") : instance.getProcAddr( "vkEndCommandBuffer"));
-      vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties(instance.getProcAddr( "vkEnumerateDeviceExtensionProperties"));
-      vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties(instance.getProcAddr( "vkEnumerateDeviceLayerProperties"));
-      vkEnumerateInstanceExtensionProperties = PFN_vkEnumerateInstanceExtensionProperties(instance.getProcAddr( "vkEnumerateInstanceExtensionProperties"));
-      vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties(instance.getProcAddr( "vkEnumerateInstanceLayerProperties"));
-      vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion(instance.getProcAddr( "vkEnumerateInstanceVersion"));
-      vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups(instance.getProcAddr( "vkEnumeratePhysicalDeviceGroups"));
-      vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR(instance.getProcAddr( "vkEnumeratePhysicalDeviceGroupsKHR"));
-      vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices(instance.getProcAddr( "vkEnumeratePhysicalDevices"));
       vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges(device ? device.getProcAddr( "vkFlushMappedMemoryRanges") : instance.getProcAddr( "vkFlushMappedMemoryRanges"));
       vkFreeCommandBuffers = PFN_vkFreeCommandBuffers(device ? device.getProcAddr( "vkFreeCommandBuffers") : instance.getProcAddr( "vkFreeCommandBuffers"));
       vkFreeDescriptorSets = PFN_vkFreeDescriptorSets(device ? device.getProcAddr( "vkFreeDescriptorSets") : instance.getProcAddr( "vkFreeDescriptorSets"));
@@ -53401,11 +53654,6 @@ public:
       vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr(device ? device.getProcAddr( "vkGetDeviceProcAddr") : instance.getProcAddr( "vkGetDeviceProcAddr"));
       vkGetDeviceQueue = PFN_vkGetDeviceQueue(device ? device.getProcAddr( "vkGetDeviceQueue") : instance.getProcAddr( "vkGetDeviceQueue"));
       vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2(device ? device.getProcAddr( "vkGetDeviceQueue2") : instance.getProcAddr( "vkGetDeviceQueue2"));
-      vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR(instance.getProcAddr( "vkGetDisplayModeProperties2KHR"));
-      vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR(instance.getProcAddr( "vkGetDisplayModePropertiesKHR"));
-      vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR(instance.getProcAddr( "vkGetDisplayPlaneCapabilities2KHR"));
-      vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR(instance.getProcAddr( "vkGetDisplayPlaneCapabilitiesKHR"));
-      vkGetDisplayPlaneSupportedDisplaysKHR = PFN_vkGetDisplayPlaneSupportedDisplaysKHR(instance.getProcAddr( "vkGetDisplayPlaneSupportedDisplaysKHR"));
       vkGetEventStatus = PFN_vkGetEventStatus(device ? device.getProcAddr( "vkGetEventStatus") : instance.getProcAddr( "vkGetEventStatus"));
       vkGetFenceFdKHR = PFN_vkGetFenceFdKHR(device ? device.getProcAddr( "vkGetFenceFdKHR") : instance.getProcAddr( "vkGetFenceFdKHR"));
       vkGetFenceStatus = PFN_vkGetFenceStatus(device ? device.getProcAddr( "vkGetFenceStatus") : instance.getProcAddr( "vkGetFenceStatus"));
@@ -53420,7 +53668,6 @@ public:
       vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2(device ? device.getProcAddr( "vkGetImageSparseMemoryRequirements2") : instance.getProcAddr( "vkGetImageSparseMemoryRequirements2"));
       vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR(device ? device.getProcAddr( "vkGetImageSparseMemoryRequirements2KHR") : instance.getProcAddr( "vkGetImageSparseMemoryRequirements2KHR"));
       vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout(device ? device.getProcAddr( "vkGetImageSubresourceLayout") : instance.getProcAddr( "vkGetImageSubresourceLayout"));
-      vkGetInstanceProcAddr = PFN_vkGetInstanceProcAddr(instance.getProcAddr( "vkGetInstanceProcAddr"));
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
       vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID(device ? device.getProcAddr( "vkGetMemoryAndroidHardwareBufferANDROID") : instance.getProcAddr( "vkGetMemoryAndroidHardwareBufferANDROID"));
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
@@ -53437,6 +53684,103 @@ public:
       vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR(device ? device.getProcAddr( "vkGetMemoryWin32HandlePropertiesKHR") : instance.getProcAddr( "vkGetMemoryWin32HandlePropertiesKHR"));
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
       vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE(device ? device.getProcAddr( "vkGetPastPresentationTimingGOOGLE") : instance.getProcAddr( "vkGetPastPresentationTimingGOOGLE"));
+      vkGetPipelineCacheData = PFN_vkGetPipelineCacheData(device ? device.getProcAddr( "vkGetPipelineCacheData") : instance.getProcAddr( "vkGetPipelineCacheData"));
+      vkGetQueryPoolResults = PFN_vkGetQueryPoolResults(device ? device.getProcAddr( "vkGetQueryPoolResults") : instance.getProcAddr( "vkGetQueryPoolResults"));
+      vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV(device ? device.getProcAddr( "vkGetRayTracingShaderGroupHandlesNV") : instance.getProcAddr( "vkGetRayTracingShaderGroupHandlesNV"));
+      vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE(device ? device.getProcAddr( "vkGetRefreshCycleDurationGOOGLE") : instance.getProcAddr( "vkGetRefreshCycleDurationGOOGLE"));
+      vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(device ? device.getProcAddr( "vkGetRenderAreaGranularity") : instance.getProcAddr( "vkGetRenderAreaGranularity"));
+      vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(device ? device.getProcAddr( "vkGetSemaphoreFdKHR") : instance.getProcAddr( "vkGetSemaphoreFdKHR"));
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+      vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR(device ? device.getProcAddr( "vkGetSemaphoreWin32HandleKHR") : instance.getProcAddr( "vkGetSemaphoreWin32HandleKHR"));
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+      vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD(device ? device.getProcAddr( "vkGetShaderInfoAMD") : instance.getProcAddr( "vkGetShaderInfoAMD"));
+      vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT(device ? device.getProcAddr( "vkGetSwapchainCounterEXT") : instance.getProcAddr( "vkGetSwapchainCounterEXT"));
+      vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR(device ? device.getProcAddr( "vkGetSwapchainImagesKHR") : instance.getProcAddr( "vkGetSwapchainImagesKHR"));
+      vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR(device ? device.getProcAddr( "vkGetSwapchainStatusKHR") : instance.getProcAddr( "vkGetSwapchainStatusKHR"));
+      vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT(device ? device.getProcAddr( "vkGetValidationCacheDataEXT") : instance.getProcAddr( "vkGetValidationCacheDataEXT"));
+      vkImportFenceFdKHR = PFN_vkImportFenceFdKHR(device ? device.getProcAddr( "vkImportFenceFdKHR") : instance.getProcAddr( "vkImportFenceFdKHR"));
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+      vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR(device ? device.getProcAddr( "vkImportFenceWin32HandleKHR") : instance.getProcAddr( "vkImportFenceWin32HandleKHR"));
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+      vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR(device ? device.getProcAddr( "vkImportSemaphoreFdKHR") : instance.getProcAddr( "vkImportSemaphoreFdKHR"));
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+      vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR(device ? device.getProcAddr( "vkImportSemaphoreWin32HandleKHR") : instance.getProcAddr( "vkImportSemaphoreWin32HandleKHR"));
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+      vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges(device ? device.getProcAddr( "vkInvalidateMappedMemoryRanges") : instance.getProcAddr( "vkInvalidateMappedMemoryRanges"));
+      vkMapMemory = PFN_vkMapMemory(device ? device.getProcAddr( "vkMapMemory") : instance.getProcAddr( "vkMapMemory"));
+      vkMergePipelineCaches = PFN_vkMergePipelineCaches(device ? device.getProcAddr( "vkMergePipelineCaches") : instance.getProcAddr( "vkMergePipelineCaches"));
+      vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT(device ? device.getProcAddr( "vkMergeValidationCachesEXT") : instance.getProcAddr( "vkMergeValidationCachesEXT"));
+      vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT(device ? device.getProcAddr( "vkRegisterDeviceEventEXT") : instance.getProcAddr( "vkRegisterDeviceEventEXT"));
+      vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT(device ? device.getProcAddr( "vkRegisterDisplayEventEXT") : instance.getProcAddr( "vkRegisterDisplayEventEXT"));
+      vkRegisterObjectsNVX = PFN_vkRegisterObjectsNVX(device ? device.getProcAddr( "vkRegisterObjectsNVX") : instance.getProcAddr( "vkRegisterObjectsNVX"));
+      vkResetCommandPool = PFN_vkResetCommandPool(device ? device.getProcAddr( "vkResetCommandPool") : instance.getProcAddr( "vkResetCommandPool"));
+      vkResetDescriptorPool = PFN_vkResetDescriptorPool(device ? device.getProcAddr( "vkResetDescriptorPool") : instance.getProcAddr( "vkResetDescriptorPool"));
+      vkResetEvent = PFN_vkResetEvent(device ? device.getProcAddr( "vkResetEvent") : instance.getProcAddr( "vkResetEvent"));
+      vkResetFences = PFN_vkResetFences(device ? device.getProcAddr( "vkResetFences") : instance.getProcAddr( "vkResetFences"));
+      vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT(device ? device.getProcAddr( "vkSetDebugUtilsObjectNameEXT") : instance.getProcAddr( "vkSetDebugUtilsObjectNameEXT"));
+      vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT(device ? device.getProcAddr( "vkSetDebugUtilsObjectTagEXT") : instance.getProcAddr( "vkSetDebugUtilsObjectTagEXT"));
+      vkSetEvent = PFN_vkSetEvent(device ? device.getProcAddr( "vkSetEvent") : instance.getProcAddr( "vkSetEvent"));
+      vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT(device ? device.getProcAddr( "vkSetHdrMetadataEXT") : instance.getProcAddr( "vkSetHdrMetadataEXT"));
+      vkTrimCommandPool = PFN_vkTrimCommandPool(device ? device.getProcAddr( "vkTrimCommandPool") : instance.getProcAddr( "vkTrimCommandPool"));
+      vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(device ? device.getProcAddr( "vkTrimCommandPoolKHR") : instance.getProcAddr( "vkTrimCommandPoolKHR"));
+      vkUnmapMemory = PFN_vkUnmapMemory(device ? device.getProcAddr( "vkUnmapMemory") : instance.getProcAddr( "vkUnmapMemory"));
+      vkUnregisterObjectsNVX = PFN_vkUnregisterObjectsNVX(device ? device.getProcAddr( "vkUnregisterObjectsNVX") : instance.getProcAddr( "vkUnregisterObjectsNVX"));
+      vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(device ? device.getProcAddr( "vkUpdateDescriptorSetWithTemplate") : instance.getProcAddr( "vkUpdateDescriptorSetWithTemplate"));
+      vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR(device ? device.getProcAddr( "vkUpdateDescriptorSetWithTemplateKHR") : instance.getProcAddr( "vkUpdateDescriptorSetWithTemplateKHR"));
+      vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets(device ? device.getProcAddr( "vkUpdateDescriptorSets") : instance.getProcAddr( "vkUpdateDescriptorSets"));
+      vkWaitForFences = PFN_vkWaitForFences(device ? device.getProcAddr( "vkWaitForFences") : instance.getProcAddr( "vkWaitForFences"));
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+      vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR(instance.getProcAddr( "vkCreateAndroidSurfaceKHR"));
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+      vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT(instance.getProcAddr( "vkCreateDebugReportCallbackEXT"));
+      vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT(instance.getProcAddr( "vkCreateDebugUtilsMessengerEXT"));
+      vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR(instance.getProcAddr( "vkCreateDisplayPlaneSurfaceKHR"));
+#ifdef VK_USE_PLATFORM_IOS_MVK
+      vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK(instance.getProcAddr( "vkCreateIOSSurfaceMVK"));
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+#ifdef VK_USE_PLATFORM_FUCHSIA
+      vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA(instance.getProcAddr( "vkCreateImagePipeSurfaceFUCHSIA"));
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+      vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK(instance.getProcAddr( "vkCreateMacOSSurfaceMVK"));
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+#ifdef VK_USE_PLATFORM_VI_NN
+      vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN(instance.getProcAddr( "vkCreateViSurfaceNN"));
+#endif /*VK_USE_PLATFORM_VI_NN*/
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+      vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR(instance.getProcAddr( "vkCreateWaylandSurfaceKHR"));
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+      vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR(instance.getProcAddr( "vkCreateWin32SurfaceKHR"));
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+#ifdef VK_USE_PLATFORM_XCB_KHR
+      vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR(instance.getProcAddr( "vkCreateXcbSurfaceKHR"));
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+      vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR(instance.getProcAddr( "vkCreateXlibSurfaceKHR"));
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+      vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT(instance.getProcAddr( "vkDebugReportMessageEXT"));
+      vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT(instance.getProcAddr( "vkDestroyDebugReportCallbackEXT"));
+      vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT(instance.getProcAddr( "vkDestroyDebugUtilsMessengerEXT"));
+      vkDestroyInstance = PFN_vkDestroyInstance(instance.getProcAddr( "vkDestroyInstance"));
+      vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR(instance.getProcAddr( "vkDestroySurfaceKHR"));
+      vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups(instance.getProcAddr( "vkEnumeratePhysicalDeviceGroups"));
+      vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR(instance.getProcAddr( "vkEnumeratePhysicalDeviceGroupsKHR"));
+      vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices(instance.getProcAddr( "vkEnumeratePhysicalDevices"));
+      vkGetInstanceProcAddr = PFN_vkGetInstanceProcAddr(instance.getProcAddr( "vkGetInstanceProcAddr"));
+      vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT(instance.getProcAddr( "vkSubmitDebugUtilsMessageEXT"));
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+      vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT(instance.getProcAddr( "vkAcquireXlibDisplayEXT"));
+#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+      vkCreateDevice = PFN_vkCreateDevice(instance.getProcAddr( "vkCreateDevice"));
+      vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR(instance.getProcAddr( "vkCreateDisplayModeKHR"));
+      vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties(instance.getProcAddr( "vkEnumerateDeviceExtensionProperties"));
+      vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties(instance.getProcAddr( "vkEnumerateDeviceLayerProperties"));
+      vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR(instance.getProcAddr( "vkGetDisplayModeProperties2KHR"));
+      vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR(instance.getProcAddr( "vkGetDisplayModePropertiesKHR"));
+      vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR(instance.getProcAddr( "vkGetDisplayPlaneCapabilities2KHR"));
+      vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR(instance.getProcAddr( "vkGetDisplayPlaneCapabilitiesKHR"));
+      vkGetDisplayPlaneSupportedDisplaysKHR = PFN_vkGetDisplayPlaneSupportedDisplaysKHR(instance.getProcAddr( "vkGetDisplayPlaneSupportedDisplaysKHR"));
       vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(instance.getProcAddr( "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"));
       vkGetPhysicalDeviceDisplayPlaneProperties2KHR = PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"));
       vkGetPhysicalDeviceDisplayPlanePropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(instance.getProcAddr( "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"));
@@ -53492,36 +53836,11 @@ public:
 #ifdef VK_USE_PLATFORM_XLIB_KHR
       vkGetPhysicalDeviceXlibPresentationSupportKHR = PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR(instance.getProcAddr( "vkGetPhysicalDeviceXlibPresentationSupportKHR"));
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
-      vkGetPipelineCacheData = PFN_vkGetPipelineCacheData(device ? device.getProcAddr( "vkGetPipelineCacheData") : instance.getProcAddr( "vkGetPipelineCacheData"));
-      vkGetQueryPoolResults = PFN_vkGetQueryPoolResults(device ? device.getProcAddr( "vkGetQueryPoolResults") : instance.getProcAddr( "vkGetQueryPoolResults"));
-      vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV(device ? device.getProcAddr( "vkGetQueueCheckpointDataNV") : instance.getProcAddr( "vkGetQueueCheckpointDataNV"));
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
       vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT(instance.getProcAddr( "vkGetRandROutputDisplayEXT"));
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-      vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV(device ? device.getProcAddr( "vkGetRayTracingShaderGroupHandlesNV") : instance.getProcAddr( "vkGetRayTracingShaderGroupHandlesNV"));
-      vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE(device ? device.getProcAddr( "vkGetRefreshCycleDurationGOOGLE") : instance.getProcAddr( "vkGetRefreshCycleDurationGOOGLE"));
-      vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(device ? device.getProcAddr( "vkGetRenderAreaGranularity") : instance.getProcAddr( "vkGetRenderAreaGranularity"));
-      vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(device ? device.getProcAddr( "vkGetSemaphoreFdKHR") : instance.getProcAddr( "vkGetSemaphoreFdKHR"));
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-      vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR(device ? device.getProcAddr( "vkGetSemaphoreWin32HandleKHR") : instance.getProcAddr( "vkGetSemaphoreWin32HandleKHR"));
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-      vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD(device ? device.getProcAddr( "vkGetShaderInfoAMD") : instance.getProcAddr( "vkGetShaderInfoAMD"));
-      vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT(device ? device.getProcAddr( "vkGetSwapchainCounterEXT") : instance.getProcAddr( "vkGetSwapchainCounterEXT"));
-      vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR(device ? device.getProcAddr( "vkGetSwapchainImagesKHR") : instance.getProcAddr( "vkGetSwapchainImagesKHR"));
-      vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR(device ? device.getProcAddr( "vkGetSwapchainStatusKHR") : instance.getProcAddr( "vkGetSwapchainStatusKHR"));
-      vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT(device ? device.getProcAddr( "vkGetValidationCacheDataEXT") : instance.getProcAddr( "vkGetValidationCacheDataEXT"));
-      vkImportFenceFdKHR = PFN_vkImportFenceFdKHR(device ? device.getProcAddr( "vkImportFenceFdKHR") : instance.getProcAddr( "vkImportFenceFdKHR"));
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-      vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR(device ? device.getProcAddr( "vkImportFenceWin32HandleKHR") : instance.getProcAddr( "vkImportFenceWin32HandleKHR"));
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-      vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR(device ? device.getProcAddr( "vkImportSemaphoreFdKHR") : instance.getProcAddr( "vkImportSemaphoreFdKHR"));
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-      vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR(device ? device.getProcAddr( "vkImportSemaphoreWin32HandleKHR") : instance.getProcAddr( "vkImportSemaphoreWin32HandleKHR"));
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-      vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges(device ? device.getProcAddr( "vkInvalidateMappedMemoryRanges") : instance.getProcAddr( "vkInvalidateMappedMemoryRanges"));
-      vkMapMemory = PFN_vkMapMemory(device ? device.getProcAddr( "vkMapMemory") : instance.getProcAddr( "vkMapMemory"));
-      vkMergePipelineCaches = PFN_vkMergePipelineCaches(device ? device.getProcAddr( "vkMergePipelineCaches") : instance.getProcAddr( "vkMergePipelineCaches"));
-      vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT(device ? device.getProcAddr( "vkMergeValidationCachesEXT") : instance.getProcAddr( "vkMergeValidationCachesEXT"));
+      vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT(instance.getProcAddr( "vkReleaseDisplayEXT"));
+      vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV(device ? device.getProcAddr( "vkGetQueueCheckpointDataNV") : instance.getProcAddr( "vkGetQueueCheckpointDataNV"));
       vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT(device ? device.getProcAddr( "vkQueueBeginDebugUtilsLabelEXT") : instance.getProcAddr( "vkQueueBeginDebugUtilsLabelEXT"));
       vkQueueBindSparse = PFN_vkQueueBindSparse(device ? device.getProcAddr( "vkQueueBindSparse") : instance.getProcAddr( "vkQueueBindSparse"));
       vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT(device ? device.getProcAddr( "vkQueueEndDebugUtilsLabelEXT") : instance.getProcAddr( "vkQueueEndDebugUtilsLabelEXT"));
@@ -53529,30 +53848,7 @@ public:
       vkQueuePresentKHR = PFN_vkQueuePresentKHR(device ? device.getProcAddr( "vkQueuePresentKHR") : instance.getProcAddr( "vkQueuePresentKHR"));
       vkQueueSubmit = PFN_vkQueueSubmit(device ? device.getProcAddr( "vkQueueSubmit") : instance.getProcAddr( "vkQueueSubmit"));
       vkQueueWaitIdle = PFN_vkQueueWaitIdle(device ? device.getProcAddr( "vkQueueWaitIdle") : instance.getProcAddr( "vkQueueWaitIdle"));
-      vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT(device ? device.getProcAddr( "vkRegisterDeviceEventEXT") : instance.getProcAddr( "vkRegisterDeviceEventEXT"));
-      vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT(device ? device.getProcAddr( "vkRegisterDisplayEventEXT") : instance.getProcAddr( "vkRegisterDisplayEventEXT"));
-      vkRegisterObjectsNVX = PFN_vkRegisterObjectsNVX(device ? device.getProcAddr( "vkRegisterObjectsNVX") : instance.getProcAddr( "vkRegisterObjectsNVX"));
-      vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT(instance.getProcAddr( "vkReleaseDisplayEXT"));
-      vkResetCommandBuffer = PFN_vkResetCommandBuffer(device ? device.getProcAddr( "vkResetCommandBuffer") : instance.getProcAddr( "vkResetCommandBuffer"));
-      vkResetCommandPool = PFN_vkResetCommandPool(device ? device.getProcAddr( "vkResetCommandPool") : instance.getProcAddr( "vkResetCommandPool"));
-      vkResetDescriptorPool = PFN_vkResetDescriptorPool(device ? device.getProcAddr( "vkResetDescriptorPool") : instance.getProcAddr( "vkResetDescriptorPool"));
-      vkResetEvent = PFN_vkResetEvent(device ? device.getProcAddr( "vkResetEvent") : instance.getProcAddr( "vkResetEvent"));
-      vkResetFences = PFN_vkResetFences(device ? device.getProcAddr( "vkResetFences") : instance.getProcAddr( "vkResetFences"));
-      vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT(device ? device.getProcAddr( "vkSetDebugUtilsObjectNameEXT") : instance.getProcAddr( "vkSetDebugUtilsObjectNameEXT"));
-      vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT(device ? device.getProcAddr( "vkSetDebugUtilsObjectTagEXT") : instance.getProcAddr( "vkSetDebugUtilsObjectTagEXT"));
-      vkSetEvent = PFN_vkSetEvent(device ? device.getProcAddr( "vkSetEvent") : instance.getProcAddr( "vkSetEvent"));
-      vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT(device ? device.getProcAddr( "vkSetHdrMetadataEXT") : instance.getProcAddr( "vkSetHdrMetadataEXT"));
-      vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT(instance.getProcAddr( "vkSubmitDebugUtilsMessageEXT"));
-      vkTrimCommandPool = PFN_vkTrimCommandPool(device ? device.getProcAddr( "vkTrimCommandPool") : instance.getProcAddr( "vkTrimCommandPool"));
-      vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(device ? device.getProcAddr( "vkTrimCommandPoolKHR") : instance.getProcAddr( "vkTrimCommandPoolKHR"));
-      vkUnmapMemory = PFN_vkUnmapMemory(device ? device.getProcAddr( "vkUnmapMemory") : instance.getProcAddr( "vkUnmapMemory"));
-      vkUnregisterObjectsNVX = PFN_vkUnregisterObjectsNVX(device ? device.getProcAddr( "vkUnregisterObjectsNVX") : instance.getProcAddr( "vkUnregisterObjectsNVX"));
-      vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(device ? device.getProcAddr( "vkUpdateDescriptorSetWithTemplate") : instance.getProcAddr( "vkUpdateDescriptorSetWithTemplate"));
-      vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR(device ? device.getProcAddr( "vkUpdateDescriptorSetWithTemplateKHR") : instance.getProcAddr( "vkUpdateDescriptorSetWithTemplateKHR"));
-      vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets(device ? device.getProcAddr( "vkUpdateDescriptorSets") : instance.getProcAddr( "vkUpdateDescriptorSets"));
-      vkWaitForFences = PFN_vkWaitForFences(device ? device.getProcAddr( "vkWaitForFences") : instance.getProcAddr( "vkWaitForFences"));
     }
   };
 } // namespace VULKAN_HPP_NAMESPACE
-
 #endif