diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index 38edd4b..2e0be4c 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -261,6 +261,12 @@ void checkAttributes( int                                                  line,
   }
 }
 
+void checkedAssignment( std::string & str, std::string const& leave, std::string const& commandName, std::string aliasName )
+{
+  str.erase( str.length() - leave.length() );
+  str += "      if ( !" + commandName + " ) " + commandName + " = " + aliasName + ";\n" + leave;
+}
+
 void checkElements( int                                               line,
                     std::vector<tinyxml2::XMLElement const *> const & elements,
                     std::map<std::string, bool> const &               required,
@@ -1418,6 +1424,10 @@ void VulkanHppGenerator::appendCommand( std::string &       str,
     enhanced += "#endif /*VULKAN_HPP_NO_SMART_HANDLE*/\n";
   }
 
+  std::string enter, leave;
+  std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions );
+  str += enter;
+
   // and append one or both of them
   if ( standard == enhanced )
   {
@@ -1441,6 +1451,21 @@ void VulkanHppGenerator::appendCommand( std::string &       str,
     str += standard + ( unchangedInterface ? "#else" : "#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE" ) + "\n" + enhanced +
            "#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/\n";
   }
+  str += leave;
+
+  // now append all the alias versions
+  if ( !commandData.aliasData.empty() )
+  {
+    CommandData aliasCommandData = commandData;
+    aliasCommandData.aliasData.clear();
+    for ( auto const & aliasData : commandData.aliasData )
+    {
+      aliasCommandData.extensions = aliasData.second.extensions;
+      aliasCommandData.feature    = aliasData.second.feature;
+      str += "\n";
+      appendCommand( str, indentation, aliasData.first, aliasCommandData, definition );
+    }
+  }
 }
 
 void VulkanHppGenerator::appendDispatchLoaderDynamic( std::string & str )
@@ -1558,59 +1583,14 @@ void VulkanHppGenerator::appendDispatchLoaderDynamic( std::string & str )
   public:
 )";
 
-  for ( auto const & handle : m_handles )
-  {
-    for ( auto const & command : handle.second.commands )
-    {
-      auto commandIt = m_commands.find( command );
-      assert( commandIt != m_commands.end() );
-      std::string enter, leave;
-      std::tie( enter, leave ) = generateProtection( commandIt->second.feature, commandIt->second.extensions );
-      str += enter + "    PFN_" + commandIt->first + " " + commandIt->first + " = 0;\n" + leave;
-    }
-  }
-
   std::string emptyFunctions;
-  std::string strDeviceFunctions;
-  std::string strDeviceFunctionsInstance;
-  std::string strInstanceFunctions;
-  for ( auto const & handle : m_handles )
+  std::string deviceFunctions;
+  std::string deviceFunctionsInstance;
+  std::string instanceFunctions;
+  for ( auto const & command : m_commands )
   {
-    for ( auto const & command : handle.second.commands )
-    {
-      if ( ( command != "vkGetInstanceProcAddr" ) )
-      {
-        auto commandIt = m_commands.find( command );
-        assert( commandIt != m_commands.end() );
-
-        std::string enter, leave;
-        std::tie( enter, leave ) = generateProtection( commandIt->second.feature, commandIt->second.extensions );
-
-        if ( handle.first.empty() )
-        {
-          assert( commandIt->second.alias.empty() );
-          emptyFunctions += enter + "      " + commandIt->first + " = PFN_" + commandIt->first +
-                            "( vkGetInstanceProcAddr( NULL, \"" + commandIt->first + "\" ) );\n" + leave;
-        }
-        else if ( !commandIt->second.params.empty() &&
-                  m_handles.find( commandIt->second.params[0].type.type ) != m_handles.end() &&
-                  commandIt->second.params[0].type.type != "VkInstance" &&
-                  commandIt->second.params[0].type.type != "VkPhysicalDevice" )
-        {
-          strDeviceFunctions += enter + "      " + commandIt->first + " = PFN_" + commandIt->first +
-                                "( vkGetDeviceProcAddr( device, \"" + commandIt->first + "\" ) );\n" + leave;
-
-          strDeviceFunctionsInstance += enter + "      " + commandIt->first + " = PFN_" + commandIt->first +
-                                        "( vkGetInstanceProcAddr( instance, \"" + commandIt->first + "\" ) );\n" +
-                                        leave;
-        }
-        else
-        {
-          strInstanceFunctions += enter + "      " + commandIt->first + " = PFN_" + commandIt->first +
-                                  "( vkGetInstanceProcAddr( instance, \"" + commandIt->first + "\" ) );\n" + leave;
-        }
-      }
-    }
+    appendDispatchLoaderDynamicCommand(
+      str, emptyFunctions, deviceFunctions, deviceFunctionsInstance, instanceFunctions, command.first, command.second );
   }
 
   // append initialization function to fetch function pointers
@@ -1679,12 +1659,12 @@ void VulkanHppGenerator::appendDispatchLoaderDynamic( std::string & str )
       VkInstance instance = static_cast<VkInstance>(instanceCpp);
 )";
 
-  str += strInstanceFunctions;
-  str += strDeviceFunctionsInstance;
+  str += instanceFunctions;
+  str += deviceFunctionsInstance;
   str += "    }\n\n";
   str += "    void init( VULKAN_HPP_NAMESPACE::Device deviceCpp ) VULKAN_HPP_NOEXCEPT\n    {\n";
   str += "      VkDevice device = static_cast<VkDevice>(deviceCpp);\n";
-  str += strDeviceFunctions;
+  str += deviceFunctions;
   str += R"(    }
   };
 
@@ -1699,33 +1679,42 @@ void VulkanHppGenerator::appendDispatchLoaderStatic( std::string & str )
   {
   public:)";
 
-  for ( auto const & handle : m_handles )
+  for ( auto const & command : m_commands )
   {
-    for ( auto const & command : handle.second.commands )
+    std::string parameterList, parameters;
+    bool        firstParam = true;
+    for ( auto param : command.second.params )
     {
-      auto commandIt = m_commands.find( command );
-      assert( commandIt != m_commands.end() );
-
-      std::string parameterList, parameters;
-      bool        firstParam = true;
-      for ( auto param : commandIt->second.params )
+      if ( !firstParam )
       {
-        if ( !firstParam )
-        {
-          parameterList += ", ";
-          parameters += ", ";
-        }
-        parameterList += param.type.prefix + ( param.type.prefix.empty() ? "" : " " ) + param.type.type +
-                         param.type.postfix + " " + param.name + constructCArraySizes( param.arraySizes );
-        parameters += param.name;
-        firstParam = false;
+        parameterList += ", ";
+        parameters += ", ";
       }
-      std::string commandName = stripPrefix( commandIt->first, "vk" );
+      parameterList += param.type.prefix + ( param.type.prefix.empty() ? "" : " " ) + param.type.type +
+                       param.type.postfix + " " + param.name + constructCArraySizes( param.arraySizes );
+      parameters += param.name;
+      firstParam = false;
+    }
+    std::string commandName = stripPrefix( command.first, "vk" );
 
+    str += "\n";
+    std::string enter, leave;
+    std::tie( enter, leave ) = generateProtection( command.second.feature, command.second.extensions );
+    str += enter + "    " + command.second.returnType + " vk" + commandName + "( " + parameterList +
+           " ) const VULKAN_HPP_NOEXCEPT\n"
+           "    {\n"
+           "      return ::vk" +
+           commandName + "( " + parameters +
+           " );\n"
+           "    }\n" +
+           leave;
+
+    for ( auto const & aliasData : command.second.aliasData )
+    {
+      commandName = stripPrefix( aliasData.first, "vk" );
       str += "\n";
-      std::string enter, leave;
-      std::tie( enter, leave ) = generateProtection( commandIt->second.feature, commandIt->second.extensions );
-      str += enter + "    " + commandIt->second.returnType + " vk" + commandName + "( " + parameterList +
+      std::tie( enter, leave ) = generateProtection( aliasData.second.feature, aliasData.second.extensions );
+      str += enter + "    " + command.second.returnType + " vk" + commandName + "( " + parameterList +
              " ) const VULKAN_HPP_NOEXCEPT\n"
              "    {\n"
              "      return ::vk" +
@@ -1792,6 +1781,101 @@ void VulkanHppGenerator::appendDispatchLoaderDefault( std::string & str )
 )";
 }
 
+void VulkanHppGenerator::appendDispatchLoaderDynamicCommand( std::string &       str,
+                                                             std::string &       emptyFunctions,
+                                                             std::string &       deviceFunctions,
+                                                             std::string &       deviceFunctionsInstance,
+                                                             std::string &       instanceFunctions,
+                                                             std::string const & commandName,
+                                                             CommandData const & commandData )
+{
+  if ( !commandData.aliasData.empty() )
+  {
+    CommandData aliasCommandData = commandData;
+    aliasCommandData.aliasData.clear();
+    for ( auto const & aliasData : commandData.aliasData )
+    {
+      aliasCommandData.extensions = aliasData.second.extensions;
+      aliasCommandData.feature    = aliasData.second.feature;
+      appendDispatchLoaderDynamicCommand( str,
+                                          emptyFunctions,
+                                          deviceFunctions,
+                                          deviceFunctionsInstance,
+                                          instanceFunctions,
+                                          aliasData.first,
+                                          aliasCommandData );
+    }
+  }
+
+  std::string enter, leave;
+  std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions );
+  str += enter + "    PFN_" + commandName + " " + commandName + " = 0;\n" + leave;
+
+  bool isDeviceFunction = !commandData.handle.empty() && !commandData.params.empty() &&
+                          ( m_handles.find( commandData.params[0].type.type ) != m_handles.end() ) &&
+                          ( commandData.params[0].type.type != "VkInstance" ) &&
+                          ( commandData.params[0].type.type != "VkPhysicalDevice" );
+
+  if ( commandData.handle.empty() )
+  {
+    assert( commandData.aliasData.empty() );
+    emptyFunctions += enter + "      " + commandName + " = PFN_" + commandName + "( vkGetInstanceProcAddr( NULL, \"" +
+                      commandName + "\" ) );\n" + leave;
+  }
+  else if ( isDeviceFunction )
+  {
+    deviceFunctions += enter + "      " + commandName + " = PFN_" + commandName + "( vkGetDeviceProcAddr( device, \"" +
+                       commandName + "\" ) );\n" + leave;
+
+    deviceFunctionsInstance += enter + "      " + commandName + " = PFN_" + commandName +
+                               "( vkGetInstanceProcAddr( instance, \"" + commandName + "\" ) );\n" + leave;
+  }
+  else
+  {
+    instanceFunctions += enter + "      " + commandName + " = PFN_" + commandName +
+                         "( vkGetInstanceProcAddr( instance, \"" + commandName + "\" ) );\n" + leave;
+  }
+
+  if ( !commandData.aliasData.empty() )
+  {
+    // first look for an alias with "KHR"-suffix
+    auto aliasKHRIt =
+      std::find_if( commandData.aliasData.begin(),
+                    commandData.aliasData.end(),
+                    []( std::pair<std::string, CommandAliasData> const & ad ) { return endsWith( ad.first, "KHR" ); } );
+    if ( aliasKHRIt != commandData.aliasData.end() )
+    {
+      assert( generateProtection( aliasKHRIt->second.feature, aliasKHRIt->second.extensions ).first.empty() );
+      if ( isDeviceFunction )
+      {
+        checkedAssignment( deviceFunctions, leave, commandName, aliasKHRIt->first );
+        checkedAssignment( deviceFunctionsInstance, leave, commandName, aliasKHRIt->first );
+      }
+      else
+      {
+        checkedAssignment( instanceFunctions, leave, commandName, aliasKHRIt->first );
+      }
+    }
+    for ( auto aliasIt = commandData.aliasData.begin(); aliasIt != commandData.aliasData.end(); ++aliasIt )
+    {
+      // then all the others, with no specific order
+      if ( aliasIt != aliasKHRIt )
+      {
+        assert( generateProtection( aliasIt->second.feature, aliasIt->second.extensions ).first.empty() );
+        if ( isDeviceFunction )
+        {
+          checkedAssignment( deviceFunctions, leave, commandName, aliasIt->first );
+          checkedAssignment( deviceFunctionsInstance, leave, commandName, aliasIt->first );
+        }
+        else
+        {
+          checkedAssignment( instanceFunctions, leave, commandName, aliasIt->first );
+        }
+      }
+    }
+  }
+}
+
 void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, EnumData> const & enumData ) const
 {
   str += "  enum class " + stripPrefix( enumData.first, "Vk" );
@@ -3096,8 +3180,8 @@ void VulkanHppGenerator::appendFunctionHeaderTemplate( std::string &       str,
       assert( !isStructureChain || !unique );
       allocator += " = std::allocator<" + ( isStructureChain ? "StructureChain" : enhancedReturnTypeBase ) + ">";
     }
-    // Use first Dispatch, then Allocator template argument for functions returning a std::vector<UniqueHandle>, as they
-    // need the Dispatch in the Allocator. For all other functions keep the previous order: first Allocator, then
+    // Use first Dispatch, then Allocator template argument for functions returning a std::vector<UniqueHandle>, as
+    // they need the Dispatch in the Allocator. For all other functions keep the previous order: first Allocator, then
     // Dispatch
     str += unique ? ( dispatch + ", " + allocator ) : ( allocator + ", " + dispatch );
   }
@@ -3154,11 +3238,7 @@ void VulkanHppGenerator::appendHandle( std::string & str, std::pair<std::string,
         appendUniqueTypes( str, "", { "VkInstance" } );
       }
       str += "\n";
-      std::string enter, leave;
-      std::tie( enter, leave ) = generateProtection( commandIt->second.feature, commandIt->second.extensions );
-      str += enter;
       appendCommand( str, "  ", commandIt->first, commandIt->second, false );
-      str += leave;
     }
   }
   else
@@ -3181,31 +3261,25 @@ void VulkanHppGenerator::appendHandle( std::string & str, std::pair<std::string,
       auto commandIt = m_commands.find( command );
       assert( commandIt != m_commands.end() );
 
-      std::string enter, leave;
-      std::tie( enter, leave ) = generateProtection( commandIt->second.feature, commandIt->second.extensions );
-
       std::string commandString;
-      commands += "\n" + enter;
       std::string commandName = determineCommandName( commandIt->first, commandIt->second.params[0].type.type );
+      commands += "\n";
       appendCommand( commands, "    ", commandIt->first, commandIt->second, false );
 
       // special handling for destroy functions
-      bool platformLeft = false;
-      if ( commandIt->second.alias.empty() &&
-           ( ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
-             ( commandIt->first.substr( 2, 4 ) == "Free" ) ) )
+      if ( ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
+           ( commandIt->first.substr( 2, 4 ) == "Free" ) )
       {
-        assert( 1 < commandIt->second.params.size() );
-        auto handleIt = m_handles.find( commandIt->second.params[1].type.type );
-        assert( handleIt != m_handles.end() );
-        if ( !handleIt->second.alias.empty() )
-        {
-          commands += leave;
-          platformLeft = true;
-        }
-
         std::string destroyCommandString;
-        appendCommand( destroyCommandString, "    ", commandIt->first, commandIt->second, false );
+        // in case there are aliases to this function, filter them out here
+        CommandData commandData = commandIt->second;
+        commandData.aliasData.clear();
+        if ( needsComplexBody( commandIt->second ) )
+        {
+          commandData.extensions.clear();
+          commandData.feature.clear();
+        }
+        appendCommand( destroyCommandString, "    ", commandIt->first, commandData, false );
         std::string shortenedName = ( commandIt->first.substr( 2, 7 ) == "Destroy" ) ? "destroy" : "free";
         size_t      pos           = destroyCommandString.find( commandName );
         while ( pos != std::string::npos )
@@ -3215,10 +3289,6 @@ void VulkanHppGenerator::appendHandle( std::string & str, std::pair<std::string,
         }
         commands += "\n" + destroyCommandString;
       }
-      if ( !platformLeft )
-      {
-        commands += leave;
-      }
     }
 
     static const std::string templateString = R"(
@@ -3342,7 +3412,7 @@ void VulkanHppGenerator::appendHandles( std::string & str )
   }
 }
 
-void VulkanHppGenerator::appendHandlesCommandDefintions( std::string & str ) const
+void VulkanHppGenerator::appendHandlesCommandDefinitions( std::string & str ) const
 {
   for ( auto const & handle : m_handles )
   {
@@ -3355,19 +3425,26 @@ void VulkanHppGenerator::appendHandlesCommandDefintions( std::string & str ) con
       std::string strippedName = startLowerCase( stripPrefix( commandIt->first, "vk" ) );
 
       str += "\n";
-      std::string enter, leave;
-      std::tie( enter, leave ) = generateProtection( commandIt->second.feature, commandIt->second.extensions );
-      str += enter;
       appendCommand( str, "  ", commandIt->first, commandIt->second, true );
 
       // special handling for destroy functions
       std::string commandName = determineCommandName( commandIt->first, commandIt->second.params[0].type.type );
-      if ( commandIt->second.alias.empty() &&
-           ( ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
-             ( commandIt->first.substr( 2, 4 ) == "Free" ) ) )
+      if ( ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
+           ( commandIt->first.substr( 2, 4 ) == "Free" ) )
       {
         std::string destroyCommandString;
-        appendCommand( destroyCommandString, "  ", commandIt->first, commandIt->second, true );
+        // in case there are aliases to this function, filter them out here
+        CommandData commandData = commandIt->second;
+        commandData.aliasData.clear();
+
+        bool complex = needsComplexBody( commandIt->second );
+        if ( complex )
+        {
+          commandData.extensions.clear();
+          commandData.feature.clear();
+        }
+
+        appendCommand( destroyCommandString, "  ", commandIt->first, commandData, true );
         std::string shortenedName = ( commandIt->first.substr( 2, 7 ) == "Destroy" ) ? "destroy" : "free";
         size_t      pos           = destroyCommandString.find( commandName );
         while ( pos != std::string::npos )
@@ -3376,64 +3453,36 @@ void VulkanHppGenerator::appendHandlesCommandDefintions( std::string & str ) con
           pos = destroyCommandString.find( commandName, pos );
         }
 
-        bool extended = false;
-        // check if this command is protected and is aliased
-        if ( !enter.empty() )
+        if ( complex )
         {
-          std::string                                                     alias = commandIt->first;
-          std::vector<std::map<std::string, CommandData>::const_iterator> aliasIts;
-          std::map<std::string, CommandData>::const_iterator              aliasIt = m_commands.begin();
-          do
+          std::string enter, leave;
+          std::tie( enter, leave ) = generateProtection( commandIt->second.feature, commandIt->second.extensions );
+
+          assert( commandIt->second.aliasData.size() == 1 );
+          auto aliasDataIt = commandIt->second.aliasData.begin();
+#if !defined( NDEBUG )
+          std::string aliasEnter, aliasLeave;
+          std::tie( aliasEnter, aliasLeave ) =
+            generateProtection( aliasDataIt->second.feature, aliasDataIt->second.extensions );
+          assert( aliasEnter.empty() );
+#endif
+
+          assert( !enter.empty() );
+          pos = destroyCommandString.find( commandIt->first );
+          while ( pos != std::string::npos )
           {
-            aliasIt =
-              std::find_if( aliasIt, m_commands.end(), [&alias]( std::pair<std::string, CommandData> const & cd ) {
-                return alias == cd.second.alias;
-              } );
-            if ( aliasIt != m_commands.end() )
-            {
-              aliasIts.push_back( aliasIt );
-              ++aliasIt;
-            }
-          } while ( aliasIt != m_commands.end() );
-
-          if ( !aliasIts.empty() )
-          {
-            assert( aliasIts.size() == 1 );
-            aliasIt = aliasIts.front();
-
-            std::string aliasEnter, aliasLeave;
-            std::tie( aliasEnter, aliasLeave ) =
-              generateProtection( aliasIt->second.feature, aliasIt->second.extensions );
-            assert( aliasEnter.empty() );
-
-            pos = destroyCommandString.find( commandIt->first );
-            while ( pos != std::string::npos )
-            {
-              assert( ( 6 < pos ) && ( destroyCommandString.substr( pos - 6, 6 ) == "    d." ) );
-              size_t endPos = destroyCommandString.find( ';', pos );
-              assert( endPos != std::string::npos );
-              std::string originalCall = destroyCommandString.substr( pos - 6, endPos - pos + 7 );
-              std::string aliasCall    = originalCall;
-              aliasCall.replace( 6, commandIt->first.length(), aliasIt->first );
-              destroyCommandString.replace(
-                pos - 6, endPos - pos + 7, enter + originalCall + "\n#else\n" + aliasCall + "\n" + leave );
-              pos      = destroyCommandString.find( commandIt->first, endPos );
-              extended = true;
-            }
+            assert( ( 6 < pos ) && ( destroyCommandString.substr( pos - 6, 6 ) == "    d." ) );
+            size_t endPos = destroyCommandString.find( ';', pos );
+            assert( endPos != std::string::npos );
+            std::string originalCall = destroyCommandString.substr( pos - 6, endPos - pos + 7 );
+            std::string aliasCall    = originalCall;
+            aliasCall.replace( 6, commandIt->first.length(), aliasDataIt->first );
+            destroyCommandString.replace(
+              pos - 6, endPos - pos + 7, enter + originalCall + "\n#else\n" + aliasCall + "\n" + leave );
+            pos = destroyCommandString.find( commandIt->first, endPos );
           }
         }
-        if ( extended )
-        {
-          str += leave + "\n" + destroyCommandString + "\n";
-        }
-        else
-        {
-          str += "\n" + destroyCommandString + leave;
-        }
-      }
-      else
-      {
-        str += leave + "\n";
+        str += "\n" + destroyCommandString;
       }
     }
   }
@@ -5259,6 +5308,12 @@ bool VulkanHppGenerator::isTwoStepAlgorithm( std::vector<ParamData> const & para
   return isTwoStep;
 }
 
+bool VulkanHppGenerator::needsComplexBody( CommandData const & commandData ) const
+{
+  return !commandData.aliasData.empty() &&
+         !generateProtection( commandData.feature, commandData.extensions ).first.empty();
+}
+
 void VulkanHppGenerator::readBaseType( tinyxml2::XMLElement const *               element,
                                        std::map<std::string, std::string> const & attributes )
 {
@@ -5486,22 +5541,9 @@ void VulkanHppGenerator::readCommandAlias( tinyxml2::XMLElement const *
 
   auto commandIt = m_commands.find( alias );
   check( commandIt != m_commands.end(), line, "missing command <" + alias + ">" );
-
-  // add the very same command as an alias
-  bool inserted;
-  std::tie( commandIt, inserted ) = m_commands.insert( std::make_pair( name, commandIt->second ) );
-  check( inserted, line, "alias <" + name + "> for command <" + alias + "> already specified" );
-  commandIt->second.alias   = alias;
-  commandIt->second.xmlLine = line;
-
-  // and add it to a handle!
-  auto handleIt = m_handles.find( commandIt->second.handle );
-  check( handleIt != m_handles.end(),
+  check( commandIt->second.aliasData.insert( std::make_pair( name, CommandAliasData( line ) ) ).second,
          line,
-         "trying to add alias command <" + name + "> to an unknown handle <" + commandIt->second.handle + ">" );
-  check( handleIt->second.commands.insert( name ).second,
-         line,
-         "alias command <" + name + "> already registered with handle <" + handleIt->first + ">" );
+         "command <" + name + "> already listed as alias to <" + alias + ">" );
 }
 
 VulkanHppGenerator::ParamData VulkanHppGenerator::readCommandParam( tinyxml2::XMLElement const *   element,
@@ -6196,8 +6238,24 @@ void VulkanHppGenerator::readExtensionRequireCommand( tinyxml2::XMLElement const
 
   // mark this command be part of this extension
   auto commandIt = m_commands.find( name );
-  check( commandIt != m_commands.end(), line, "extension <" + extension + "> requires unknown command <" + name + ">" );
-  commandIt->second.extensions.insert( extension );
+  if ( commandIt == m_commands.end() )
+  {
+    bool foundAlias = false;
+    for ( commandIt = m_commands.begin(); !foundAlias && commandIt != m_commands.end(); ++commandIt )
+    {
+      auto aliasDataIt = commandIt->second.aliasData.find( name );
+      if ( aliasDataIt != commandIt->second.aliasData.end() )
+      {
+        aliasDataIt->second.extensions.insert( extension );
+        foundAlias = true;
+      }
+    }
+    check( foundAlias, line, "extension <" + extension + "> requires unknown command <" + name + ">" );
+  }
+  else
+  {
+    commandIt->second.extensions.insert( extension );
+  }
 }
 
 void VulkanHppGenerator::readExtensionRequireType( tinyxml2::XMLElement const * element, std::string const & extension )
@@ -8997,7 +9055,7 @@ namespace std
     str += "#endif\n" + structResultValue;
     generator.appendStructs( str );
     generator.appendHandles( str );
-    generator.appendHandlesCommandDefintions( str );
+    generator.appendHandlesCommandDefinitions( str );
     generator.appendStructureChainValidation( str );
     generator.appendDispatchLoaderDynamic( str );
     str += "} // namespace VULKAN_HPP_NAMESPACE\n";
diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp
index 5dd869a..729bce4 100644
--- a/VulkanHppGenerator.hpp
+++ b/VulkanHppGenerator.hpp
@@ -33,7 +33,7 @@ public:
     std::string & str );  // typedef to DispatchLoaderStatic or undefined type, based on VK_NO_PROTOTYPES
   void                appendEnums( std::string & str ) const;
   void                appendHandles( std::string & str );
-  void                appendHandlesCommandDefintions( std::string & str ) const;
+  void                appendHandlesCommandDefinitions( std::string & str ) const;
   void                appendHashStructures( std::string & str ) const;
   void                appendResultExceptions( std::string & str ) const;
   void                appendStructs( std::string & str );
@@ -98,19 +98,28 @@ private:
     int                      xmlLine;
   };
 
+  struct CommandAliasData
+  {
+    CommandAliasData( int line ) : xmlLine( line ) {}
+
+    std::set<std::string> extensions;
+    std::string           feature;
+    int         xmlLine;
+  };
+
   struct CommandData
   {
     CommandData( int line ) : xmlLine( line ) {}
 
-    std::string              alias;
-    std::vector<std::string> errorCodes;
-    std::set<std::string>    extensions;
-    std::string              feature;
-    std::string              handle;
-    std::vector<ParamData>   params;
-    std::string              returnType;
-    std::vector<std::string> successCodes;
-    int                      xmlLine;
+    std::map<std::string,CommandAliasData> aliasData;
+    std::vector<std::string>      errorCodes;
+    std::set<std::string>         extensions;
+    std::string                   feature;
+    std::string                   handle;
+    std::vector<ParamData>        params;
+    std::string                   returnType;
+    std::vector<std::string>      successCodes;
+    int                           xmlLine;
   };
 
   struct EnumValueData
@@ -292,7 +301,15 @@ private:
                              std::string const & name,
                              CommandData const & commandData,
                              bool                definition ) const;
-  void        appendEnum( std::string & str, std::pair<std::string, EnumData> const & enumData ) const;
+  void        appendDispatchLoaderDynamicCommand( std::string &       str,
+                                                  std::string &       emptyFunctions,
+                                                  std::string &       deviceFunctions,
+                                                  std::string &       deviceFunctionsInstance,
+                                                  std::string &       instanceFunctions,
+                                                  std::string const & commandName,
+                                                  CommandData const & commandData );
+  void        appendEnum( std::string & str,
+                                                       std::pair<std::string, EnumData> const & enumData ) const;
   void        appendEnumInitializer( std::string &                      str,
                                      TypeInfo const &                   type,
                                      std::vector<std::string> const &   arraySizes,
@@ -529,6 +546,7 @@ private:
   bool                  isParam( std::string const & name, std::vector<ParamData> const & params ) const;
   bool                  isParamIndirect( std::string const & name, std::vector<ParamData> const & params ) const;
   bool                  isTwoStepAlgorithm( std::vector<ParamData> const & params ) const;
+  bool                  needsComplexBody( CommandData const & commandData ) const;
   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( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp
index 105441b..4f34776 100644
--- a/vulkan/vulkan.hpp
+++ b/vulkan/vulkan.hpp
@@ -1229,29 +1229,73 @@ namespace VULKAN_HPP_NAMESPACE
   class DispatchLoaderStatic
   {
   public:
-    VkResult vkCreateInstance( const VkInstanceCreateInfo *  pCreateInfo,
+#  ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult vkAcquireNextImage2KHR( VkDevice                          device,
+                                     const VkAcquireNextImageInfoKHR * pAcquireInfo,
+                                     uint32_t *                        pImageIndex ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex );
+    }
+
+    VkResult vkAcquireNextImageKHR( VkDevice       device,
+                                    VkSwapchainKHR swapchain,
+                                    uint64_t       timeout,
+                                    VkSemaphore    semaphore,
+                                    VkFence        fence,
+                                    uint32_t *     pImageIndex ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex );
+    }
+
+    VkResult vkAcquirePerformanceConfigurationINTEL( VkDevice                                           device,
+                                                     const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
+                                                     VkPerformanceConfigurationINTEL * pConfiguration ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration );
+    }
+
+    VkResult vkAcquireProfilingLockKHR( VkDevice                              device,
+                                        const VkAcquireProfilingLockInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireProfilingLockKHR( device, pInfo );
+    }
+
+#  ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+    VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice,
+                                      Display *        dpy,
+                                      VkDisplayKHR     display ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display );
+    }
+#  endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+    VkResult vkAllocateCommandBuffers( VkDevice                            device,
+                                       const VkCommandBufferAllocateInfo * pAllocateInfo,
+                                       VkCommandBuffer *                   pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
+    }
+
+    VkResult vkAllocateDescriptorSets( VkDevice                            device,
+                                       const VkDescriptorSetAllocateInfo * pAllocateInfo,
+                                       VkDescriptorSet *                   pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets );
+    }
+
+    VkResult vkAllocateMemory( VkDevice                      device,
+                               const VkMemoryAllocateInfo *  pAllocateInfo,
                                const VkAllocationCallbacks * pAllocator,
-                               VkInstance *                  pInstance ) const VULKAN_HPP_NOEXCEPT
+                               VkDeviceMemory *              pMemory ) const VULKAN_HPP_NOEXCEPT
     {
-      return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance );
-    }
-
-    VkResult vkEnumerateInstanceExtensionProperties( const char *            pLayerName,
-                                                     uint32_t *              pPropertyCount,
-                                                     VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties );
-    }
-
-    VkResult vkEnumerateInstanceLayerProperties( uint32_t *          pPropertyCount,
-                                                 VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties );
-    }
-
-    VkResult vkEnumerateInstanceVersion( uint32_t * pApiVersion ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumerateInstanceVersion( pApiVersion );
+      return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory );
     }
 
     VkResult vkBeginCommandBuffer( VkCommandBuffer                  commandBuffer,
@@ -1260,6 +1304,79 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo );
     }
 
+#  ifdef VK_ENABLE_BETA_EXTENSIONS
+    VkResult vkBindAccelerationStructureMemoryKHR( VkDevice                                         device,
+                                                   uint32_t                                         bindInfoCount,
+                                                   const VkBindAccelerationStructureMemoryInfoKHR * pBindInfos ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindAccelerationStructureMemoryKHR( device, bindInfoCount, pBindInfos );
+    }
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+    VkResult vkBindAccelerationStructureMemoryNV( VkDevice                                         device,
+                                                  uint32_t                                         bindInfoCount,
+                                                  const VkBindAccelerationStructureMemoryInfoKHR * pBindInfos ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindBufferMemory( VkDevice       device,
+                                 VkBuffer       buffer,
+                                 VkDeviceMemory memory,
+                                 VkDeviceSize   memoryOffset ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindBufferMemory( device, buffer, memory, memoryOffset );
+    }
+
+    VkResult vkBindBufferMemory2( VkDevice                       device,
+                                  uint32_t                       bindInfoCount,
+                                  const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindBufferMemory2KHR( VkDevice                       device,
+                                     uint32_t                       bindInfoCount,
+                                     const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindImageMemory( VkDevice       device,
+                                VkImage        image,
+                                VkDeviceMemory memory,
+                                VkDeviceSize   memoryOffset ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindImageMemory( device, image, memory, memoryOffset );
+    }
+
+    VkResult vkBindImageMemory2( VkDevice                      device,
+                                 uint32_t                      bindInfoCount,
+                                 const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos );
+    }
+
+    VkResult vkBindImageMemory2KHR( VkDevice                      device,
+                                    uint32_t                      bindInfoCount,
+                                    const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos );
+    }
+
+#  ifdef VK_ENABLE_BETA_EXTENSIONS
+    VkResult vkBuildAccelerationStructureKHR(
+      VkDevice                                                  device,
+      uint32_t                                                  infoCount,
+      const VkAccelerationStructureBuildGeometryInfoKHR *       pInfos,
+      const VkAccelerationStructureBuildOffsetInfoKHR * const * ppOffsetInfos ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkBuildAccelerationStructureKHR( device, infoCount, pInfos, ppOffsetInfos );
+    }
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
     void vkCmdBeginConditionalRenderingEXT(
       VkCommandBuffer                            commandBuffer,
       const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT
@@ -2341,150 +2458,6 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query );
     }
 
-    VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEndCommandBuffer( commandBuffer );
-    }
-
-    VkResult vkResetCommandBuffer( VkCommandBuffer           commandBuffer,
-                                   VkCommandBufferResetFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetCommandBuffer( commandBuffer, flags );
-    }
-
-#  ifdef VK_USE_PLATFORM_WIN32_KHR
-    VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain );
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    VkResult vkAcquireNextImage2KHR( VkDevice                          device,
-                                     const VkAcquireNextImageInfoKHR * pAcquireInfo,
-                                     uint32_t *                        pImageIndex ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex );
-    }
-
-    VkResult vkAcquireNextImageKHR( VkDevice       device,
-                                    VkSwapchainKHR swapchain,
-                                    uint64_t       timeout,
-                                    VkSemaphore    semaphore,
-                                    VkFence        fence,
-                                    uint32_t *     pImageIndex ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex );
-    }
-
-    VkResult vkAcquirePerformanceConfigurationINTEL( VkDevice                                           device,
-                                                     const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
-                                                     VkPerformanceConfigurationINTEL * pConfiguration ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration );
-    }
-
-    VkResult vkAcquireProfilingLockKHR( VkDevice                              device,
-                                        const VkAcquireProfilingLockInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquireProfilingLockKHR( device, pInfo );
-    }
-
-    VkResult vkAllocateCommandBuffers( VkDevice                            device,
-                                       const VkCommandBufferAllocateInfo * pAllocateInfo,
-                                       VkCommandBuffer *                   pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
-    }
-
-    VkResult vkAllocateDescriptorSets( VkDevice                            device,
-                                       const VkDescriptorSetAllocateInfo * pAllocateInfo,
-                                       VkDescriptorSet *                   pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets );
-    }
-
-    VkResult vkAllocateMemory( VkDevice                      device,
-                               const VkMemoryAllocateInfo *  pAllocateInfo,
-                               const VkAllocationCallbacks * pAllocator,
-                               VkDeviceMemory *              pMemory ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory );
-    }
-
-#  ifdef VK_ENABLE_BETA_EXTENSIONS
-    VkResult vkBindAccelerationStructureMemoryKHR( VkDevice                                         device,
-                                                   uint32_t                                         bindInfoCount,
-                                                   const VkBindAccelerationStructureMemoryInfoKHR * pBindInfos ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindAccelerationStructureMemoryKHR( device, bindInfoCount, pBindInfos );
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    VkResult vkBindAccelerationStructureMemoryNV( VkDevice                                         device,
-                                                  uint32_t                                         bindInfoCount,
-                                                  const VkBindAccelerationStructureMemoryInfoKHR * pBindInfos ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos );
-    }
-
-    VkResult vkBindBufferMemory( VkDevice       device,
-                                 VkBuffer       buffer,
-                                 VkDeviceMemory memory,
-                                 VkDeviceSize   memoryOffset ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindBufferMemory( device, buffer, memory, memoryOffset );
-    }
-
-    VkResult vkBindBufferMemory2( VkDevice                       device,
-                                  uint32_t                       bindInfoCount,
-                                  const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos );
-    }
-
-    VkResult vkBindBufferMemory2KHR( VkDevice                       device,
-                                     uint32_t                       bindInfoCount,
-                                     const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos );
-    }
-
-    VkResult vkBindImageMemory( VkDevice       device,
-                                VkImage        image,
-                                VkDeviceMemory memory,
-                                VkDeviceSize   memoryOffset ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindImageMemory( device, image, memory, memoryOffset );
-    }
-
-    VkResult vkBindImageMemory2( VkDevice                      device,
-                                 uint32_t                      bindInfoCount,
-                                 const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos );
-    }
-
-    VkResult vkBindImageMemory2KHR( VkDevice                      device,
-                                    uint32_t                      bindInfoCount,
-                                    const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos );
-    }
-
-#  ifdef VK_ENABLE_BETA_EXTENSIONS
-    VkResult vkBuildAccelerationStructureKHR(
-      VkDevice                                                  device,
-      uint32_t                                                  infoCount,
-      const VkAccelerationStructureBuildGeometryInfoKHR *       pInfos,
-      const VkAccelerationStructureBuildOffsetInfoKHR * const * ppOffsetInfos ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkBuildAccelerationStructureKHR( device, infoCount, pInfos, ppOffsetInfos );
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
     VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const VULKAN_HPP_NOEXCEPT
     {
       return ::vkCompileDeferredNV( device, pipeline, shader );
@@ -2535,6 +2508,16 @@ namespace VULKAN_HPP_NAMESPACE
       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 VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
     VkResult vkCreateBuffer( VkDevice                      device,
                              const VkBufferCreateInfo *    pCreateInfo,
                              const VkAllocationCallbacks * pAllocator,
@@ -2569,6 +2552,22 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
     }
 
+    VkResult vkCreateDebugReportCallbackEXT( VkInstance                                 instance,
+                                             const VkDebugReportCallbackCreateInfoEXT * pCreateInfo,
+                                             const VkAllocationCallbacks *              pAllocator,
+                                             VkDebugReportCallbackEXT * pCallback ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback );
+    }
+
+    VkResult vkCreateDebugUtilsMessengerEXT( VkInstance                                 instance,
+                                             const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,
+                                             const VkAllocationCallbacks *              pAllocator,
+                                             VkDebugUtilsMessengerEXT * pMessenger ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
+    }
+
 #  ifdef VK_ENABLE_BETA_EXTENSIONS
     VkResult vkCreateDeferredOperationKHR( VkDevice                      device,
                                            const VkAllocationCallbacks * pAllocator,
@@ -2612,6 +2611,41 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
     }
 
+    VkResult vkCreateDevice( VkPhysicalDevice              physicalDevice,
+                             const VkDeviceCreateInfo *    pCreateInfo,
+                             const VkAllocationCallbacks * pAllocator,
+                             VkDevice *                    pDevice ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice );
+    }
+
+#  ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    VkResult vkCreateDirectFBSurfaceEXT( VkInstance                             instance,
+                                         const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,
+                                         const VkAllocationCallbacks *          pAllocator,
+                                         VkSurfaceKHR *                         pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
+    VkResult vkCreateDisplayModeKHR( VkPhysicalDevice                   physicalDevice,
+                                     VkDisplayKHR                       display,
+                                     const VkDisplayModeCreateInfoKHR * pCreateInfo,
+                                     const VkAllocationCallbacks *      pAllocator,
+                                     VkDisplayModeKHR *                 pMode ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode );
+    }
+
+    VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance                            instance,
+                                             const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,
+                                             const VkAllocationCallbacks *         pAllocator,
+                                             VkSurfaceKHR *                        pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
+
     VkResult vkCreateEvent( VkDevice                      device,
                             const VkEventCreateInfo *     pCreateInfo,
                             const VkAllocationCallbacks * pAllocator,
@@ -2647,6 +2681,24 @@ namespace VULKAN_HPP_NAMESPACE
         device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
     }
 
+    VkResult vkCreateHeadlessSurfaceEXT( VkInstance                             instance,
+                                         const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo,
+                                         const VkAllocationCallbacks *          pAllocator,
+                                         VkSurfaceKHR *                         pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+    }
+
+#  ifdef VK_USE_PLATFORM_IOS_MVK
+    VkResult vkCreateIOSSurfaceMVK( VkInstance                        instance,
+                                    const VkIOSSurfaceCreateInfoMVK * pCreateInfo,
+                                    const VkAllocationCallbacks *     pAllocator,
+                                    VkSurfaceKHR *                    pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_IOS_MVK*/
+
     VkResult vkCreateImage( VkDevice                      device,
                             const VkImageCreateInfo *     pCreateInfo,
                             const VkAllocationCallbacks * pAllocator,
@@ -2655,6 +2707,16 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage );
     }
 
+#  ifdef VK_USE_PLATFORM_FUCHSIA
+    VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance                                  instance,
+                                              const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
+                                              const VkAllocationCallbacks *               pAllocator,
+                                              VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_FUCHSIA*/
+
     VkResult vkCreateImageView( VkDevice                      device,
                                 const VkImageViewCreateInfo * pCreateInfo,
                                 const VkAllocationCallbacks * pAllocator,
@@ -2672,6 +2734,33 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCreateIndirectCommandsLayoutNV( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
     }
 
+    VkResult vkCreateInstance( const VkInstanceCreateInfo *  pCreateInfo,
+                               const VkAllocationCallbacks * pAllocator,
+                               VkInstance *                  pInstance ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance );
+    }
+
+#  ifdef VK_USE_PLATFORM_MACOS_MVK
+    VkResult vkCreateMacOSSurfaceMVK( VkInstance                          instance,
+                                      const VkMacOSSurfaceCreateInfoMVK * pCreateInfo,
+                                      const VkAllocationCallbacks *       pAllocator,
+                                      VkSurfaceKHR *                      pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
+#  ifdef VK_USE_PLATFORM_METAL_EXT
+    VkResult vkCreateMetalSurfaceEXT( VkInstance                          instance,
+                                      const VkMetalSurfaceCreateInfoEXT * pCreateInfo,
+                                      const VkAllocationCallbacks *       pAllocator,
+                                      VkSurfaceKHR *                      pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_METAL_EXT*/
+
     VkResult vkCreatePipelineCache( VkDevice                          device,
                                     const VkPipelineCacheCreateInfo * pCreateInfo,
                                     const VkAllocationCallbacks *     pAllocator,
@@ -2801,6 +2890,16 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains );
     }
 
+#  ifdef VK_USE_PLATFORM_GGP
+    VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance                                     instance,
+                                                 const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
+                                                 const VkAllocationCallbacks *                  pAllocator,
+                                                 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_GGP*/
+
     VkResult vkCreateSwapchainKHR( VkDevice                         device,
                                    const VkSwapchainCreateInfoKHR * pCreateInfo,
                                    const VkAllocationCallbacks *    pAllocator,
@@ -2817,6 +2916,56 @@ namespace VULKAN_HPP_NAMESPACE
       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 VULKAN_HPP_NOEXCEPT
+    {
+      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 VULKAN_HPP_NOEXCEPT
+    {
+      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 VULKAN_HPP_NOEXCEPT
+    {
+      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 VULKAN_HPP_NOEXCEPT
+    {
+      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 VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
     VkResult vkDebugMarkerSetObjectNameEXT( VkDevice                               device,
                                             const VkDebugMarkerObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
     {
@@ -2829,6 +2978,19 @@ namespace VULKAN_HPP_NAMESPACE
       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 VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDebugReportMessageEXT(
+        instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage );
+    }
+
 #  ifdef VK_ENABLE_BETA_EXTENSIONS
     VkResult vkDeferredOperationJoinKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
     {
@@ -2873,6 +3035,20 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkDestroyCommandPool( device, commandPool, pAllocator );
     }
 
+    void vkDestroyDebugReportCallbackEXT( VkInstance                    instance,
+                                          VkDebugReportCallbackEXT      callback,
+                                          const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator );
+    }
+
+    void vkDestroyDebugUtilsMessengerEXT( VkInstance                    instance,
+                                          VkDebugUtilsMessengerEXT      messenger,
+                                          const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
+    }
+
 #  ifdef VK_ENABLE_BETA_EXTENSIONS
     void vkDestroyDeferredOperationKHR( VkDevice                      device,
                                         VkDeferredOperationKHR        operation,
@@ -2957,6 +3133,11 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkDestroyIndirectCommandsLayoutNV( device, indirectCommandsLayout, pAllocator );
     }
 
+    void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroyInstance( instance, pAllocator );
+    }
+
     void vkDestroyPipeline( VkDevice                      device,
                             VkPipeline                    pipeline,
                             const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
@@ -3034,6 +3215,13 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkDestroyShaderModule( device, shaderModule, pAllocator );
     }
 
+    void vkDestroySurfaceKHR( VkInstance                    instance,
+                              VkSurfaceKHR                  surface,
+                              const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkDestroySurfaceKHR( instance, surface, pAllocator );
+    }
+
     void vkDestroySwapchainKHR( VkDevice                      device,
                                 VkSwapchainKHR                swapchain,
                                 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
@@ -3060,6 +3248,79 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo );
     }
 
+    VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEndCommandBuffer( commandBuffer );
+    }
+
+    VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice        physicalDevice,
+                                                   const char *            pLayerName,
+                                                   uint32_t *              pPropertyCount,
+                                                   VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties );
+    }
+
+    VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice    physicalDevice,
+                                               uint32_t *          pPropertyCount,
+                                               VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
+    }
+
+    VkResult vkEnumerateInstanceExtensionProperties( const char *            pLayerName,
+                                                     uint32_t *              pPropertyCount,
+                                                     VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties );
+    }
+
+    VkResult vkEnumerateInstanceLayerProperties( uint32_t *          pPropertyCount,
+                                                 VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties );
+    }
+
+    VkResult vkEnumerateInstanceVersion( uint32_t * pApiVersion ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumerateInstanceVersion( pApiVersion );
+    }
+
+    VkResult vkEnumeratePhysicalDeviceGroups( VkInstance                        instance,
+                                              uint32_t *                        pPhysicalDeviceGroupCount,
+                                              VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
+    }
+
+    VkResult vkEnumeratePhysicalDeviceGroupsKHR(
+      VkInstance                        instance,
+      uint32_t *                        pPhysicalDeviceGroupCount,
+      VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumeratePhysicalDeviceGroupsKHR(
+        instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
+    }
+
+    VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+      VkPhysicalDevice                     physicalDevice,
+      uint32_t                             queueFamilyIndex,
+      uint32_t *                           pCounterCount,
+      VkPerformanceCounterKHR *            pCounters,
+      VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+        physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions );
+    }
+
+    VkResult vkEnumeratePhysicalDevices( VkInstance         instance,
+                                         uint32_t *         pPhysicalDeviceCount,
+                                         VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices );
+    }
+
     VkResult vkFlushMappedMemoryRanges( VkDevice                    device,
                                         uint32_t                    memoryRangeCount,
                                         const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
@@ -3314,6 +3575,46 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue );
     }
 
+    VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice              physicalDevice,
+                                             VkDisplayKHR                  display,
+                                             uint32_t *                    pPropertyCount,
+                                             VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
+    }
+
+    VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice             physicalDevice,
+                                            VkDisplayKHR                 display,
+                                            uint32_t *                   pPropertyCount,
+                                            VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties );
+    }
+
+    VkResult
+      vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice                 physicalDevice,
+                                         const VkDisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
+                                         VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities );
+    }
+
+    VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice                physicalDevice,
+                                               VkDisplayModeKHR                mode,
+                                               uint32_t                        planeIndex,
+                                               VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities );
+    }
+
+    VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice,
+                                                    uint32_t         planeIndex,
+                                                    uint32_t *       pDisplayCount,
+                                                    VkDisplayKHR *   pDisplays ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays );
+    }
+
     VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
     {
       return ::vkGetEventStatus( device, event );
@@ -3425,6 +3726,11 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkGetImageViewHandleNVX( device, pInfo );
     }
 
+    PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetInstanceProcAddr( instance, pName );
+    }
+
 #  ifdef VK_USE_PLATFORM_ANDROID_KHR
     VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice                                            device,
                                                       const VkMemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
@@ -3503,786 +3809,6 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkGetPerformanceParameterINTEL( device, parameter, pValue );
     }
 
-    VkResult vkGetPipelineCacheData( VkDevice        device,
-                                     VkPipelineCache pipelineCache,
-                                     size_t *        pDataSize,
-                                     void *          pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
-    }
-
-    VkResult vkGetPipelineExecutableInternalRepresentationsKHR(
-      VkDevice                                        device,
-      const VkPipelineExecutableInfoKHR *             pExecutableInfo,
-      uint32_t *                                      pInternalRepresentationCount,
-      VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPipelineExecutableInternalRepresentationsKHR(
-        device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations );
-    }
-
-    VkResult
-      vkGetPipelineExecutablePropertiesKHR( VkDevice                            device,
-                                            const VkPipelineInfoKHR *           pPipelineInfo,
-                                            uint32_t *                          pExecutableCount,
-                                            VkPipelineExecutablePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties );
-    }
-
-    VkResult
-      vkGetPipelineExecutableStatisticsKHR( VkDevice                            device,
-                                            const VkPipelineExecutableInfoKHR * pExecutableInfo,
-                                            uint32_t *                          pStatisticCount,
-                                            VkPipelineExecutableStatisticKHR *  pStatistics ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics );
-    }
-
-    void vkGetPrivateDataEXT( VkDevice             device,
-                              VkObjectType         objectType,
-                              uint64_t             objectHandle,
-                              VkPrivateDataSlotEXT privateDataSlot,
-                              uint64_t *           pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, pData );
-    }
-
-    VkResult vkGetQueryPoolResults( VkDevice           device,
-                                    VkQueryPool        queryPool,
-                                    uint32_t           firstQuery,
-                                    uint32_t           queryCount,
-                                    size_t             dataSize,
-                                    void *             pData,
-                                    VkDeviceSize       stride,
-                                    VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
-    }
-
-#  ifdef VK_ENABLE_BETA_EXTENSIONS
-    VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( VkDevice   device,
-                                                                VkPipeline pipeline,
-                                                                uint32_t   firstGroup,
-                                                                uint32_t   groupCount,
-                                                                size_t     dataSize,
-                                                                void *     pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
-        device, pipeline, firstGroup, groupCount, dataSize, pData );
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#  ifdef VK_ENABLE_BETA_EXTENSIONS
-    VkResult vkGetRayTracingShaderGroupHandlesKHR( VkDevice   device,
-                                                   VkPipeline pipeline,
-                                                   uint32_t   firstGroup,
-                                                   uint32_t   groupCount,
-                                                   size_t     dataSize,
-                                                   void *     pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-    VkResult vkGetRayTracingShaderGroupHandlesNV( VkDevice   device,
-                                                  VkPipeline pipeline,
-                                                  uint32_t   firstGroup,
-                                                  uint32_t   groupCount,
-                                                  size_t     dataSize,
-                                                  void *     pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData );
-    }
-
-    VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice                       device,
-                                              VkSwapchainKHR                 swapchain,
-                                              VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties );
-    }
-
-    void vkGetRenderAreaGranularity( VkDevice     device,
-                                     VkRenderPass renderPass,
-                                     VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
-    }
-
-    VkResult
-      vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSemaphoreCounterValue( device, semaphore, pValue );
-    }
-
-    VkResult vkGetSemaphoreCounterValueKHR( VkDevice    device,
-                                            VkSemaphore semaphore,
-                                            uint64_t *  pValue ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue );
-    }
-
-    VkResult vkGetSemaphoreFdKHR( VkDevice                        device,
-                                  const VkSemaphoreGetFdInfoKHR * pGetFdInfo,
-                                  int *                           pFd ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
-    }
-
-#  ifdef VK_USE_PLATFORM_WIN32_KHR
-    VkResult vkGetSemaphoreWin32HandleKHR( VkDevice                                 device,
-                                           const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
-                                           HANDLE *                                 pHandle ) const VULKAN_HPP_NOEXCEPT
-    {
-      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 VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo );
-    }
-
-    VkResult vkGetSwapchainCounterEXT( VkDevice                    device,
-                                       VkSwapchainKHR              swapchain,
-                                       VkSurfaceCounterFlagBitsEXT counter,
-                                       uint64_t *                  pCounterValue ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue );
-    }
-
-    VkResult vkGetSwapchainImagesKHR( VkDevice       device,
-                                      VkSwapchainKHR swapchain,
-                                      uint32_t *     pSwapchainImageCount,
-                                      VkImage *      pSwapchainImages ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages );
-    }
-
-    VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetSwapchainStatusKHR( device, swapchain );
-    }
-
-    VkResult vkGetValidationCacheDataEXT( VkDevice             device,
-                                          VkValidationCacheEXT validationCache,
-                                          size_t *             pDataSize,
-                                          void *               pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
-    }
-
-    VkResult vkImportFenceFdKHR( VkDevice                       device,
-                                 const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
-    }
-
-#  ifdef VK_USE_PLATFORM_WIN32_KHR
-    VkResult vkImportFenceWin32HandleKHR(
-      VkDevice device, const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo );
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    VkResult
-      vkImportSemaphoreFdKHR( VkDevice                           device,
-                              const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo );
-    }
-
-#  ifdef VK_USE_PLATFORM_WIN32_KHR
-    VkResult vkImportSemaphoreWin32HandleKHR(
-      VkDevice                                    device,
-      const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo );
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    VkResult vkInitializePerformanceApiINTEL(
-      VkDevice device, const VkInitializePerformanceApiInfoINTEL * pInitializeInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo );
-    }
-
-    VkResult vkInvalidateMappedMemoryRanges( VkDevice                    device,
-                                             uint32_t                    memoryRangeCount,
-                                             const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
-    }
-
-    VkResult vkMapMemory( VkDevice         device,
-                          VkDeviceMemory   memory,
-                          VkDeviceSize     offset,
-                          VkDeviceSize     size,
-                          VkMemoryMapFlags flags,
-                          void **          ppData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkMapMemory( device, memory, offset, size, flags, ppData );
-    }
-
-    VkResult vkMergePipelineCaches( VkDevice                device,
-                                    VkPipelineCache         dstCache,
-                                    uint32_t                srcCacheCount,
-                                    const VkPipelineCache * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches );
-    }
-
-    VkResult vkMergeValidationCachesEXT( VkDevice                     device,
-                                         VkValidationCacheEXT         dstCache,
-                                         uint32_t                     srcCacheCount,
-                                         const VkValidationCacheEXT * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches );
-    }
-
-    VkResult vkRegisterDeviceEventEXT( VkDevice                      device,
-                                       const VkDeviceEventInfoEXT *  pDeviceEventInfo,
-                                       const VkAllocationCallbacks * pAllocator,
-                                       VkFence *                     pFence ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence );
-    }
-
-    VkResult vkRegisterDisplayEventEXT( VkDevice                      device,
-                                        VkDisplayKHR                  display,
-                                        const VkDisplayEventInfoEXT * pDisplayEventInfo,
-                                        const VkAllocationCallbacks * pAllocator,
-                                        VkFence *                     pFence ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence );
-    }
-
-#  ifdef VK_USE_PLATFORM_WIN32_KHR
-    VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain );
-    }
-#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    VkResult
-      vkReleasePerformanceConfigurationINTEL( VkDevice                        device,
-                                              VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkReleasePerformanceConfigurationINTEL( device, configuration );
-    }
-
-    void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkReleaseProfilingLockKHR( device );
-    }
-
-    VkResult vkResetCommandPool( VkDevice                device,
-                                 VkCommandPool           commandPool,
-                                 VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetCommandPool( device, commandPool, flags );
-    }
-
-    VkResult vkResetDescriptorPool( VkDevice                   device,
-                                    VkDescriptorPool           descriptorPool,
-                                    VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetDescriptorPool( device, descriptorPool, flags );
-    }
-
-    VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetEvent( device, event );
-    }
-
-    VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetFences( device, fenceCount, pFences );
-    }
-
-    void vkResetQueryPool( VkDevice    device,
-                           VkQueryPool queryPool,
-                           uint32_t    firstQuery,
-                           uint32_t    queryCount ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount );
-    }
-
-    void vkResetQueryPoolEXT( VkDevice    device,
-                              VkQueryPool queryPool,
-                              uint32_t    firstQuery,
-                              uint32_t    queryCount ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount );
-    }
-
-    VkResult vkSetDebugUtilsObjectNameEXT( VkDevice                              device,
-                                           const VkDebugUtilsObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo );
-    }
-
-    VkResult vkSetDebugUtilsObjectTagEXT( VkDevice                             device,
-                                          const VkDebugUtilsObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo );
-    }
-
-    VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetEvent( device, event );
-    }
-
-    void vkSetHdrMetadataEXT( VkDevice                 device,
-                              uint32_t                 swapchainCount,
-                              const VkSwapchainKHR *   pSwapchains,
-                              const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata );
-    }
-
-    void vkSetLocalDimmingAMD( VkDevice       device,
-                               VkSwapchainKHR swapChain,
-                               VkBool32       localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable );
-    }
-
-    VkResult vkSetPrivateDataEXT( VkDevice             device,
-                                  VkObjectType         objectType,
-                                  uint64_t             objectHandle,
-                                  VkPrivateDataSlotEXT privateDataSlot,
-                                  uint64_t             data ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, data );
-    }
-
-    VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSignalSemaphore( device, pSignalInfo );
-    }
-
-    VkResult vkSignalSemaphoreKHR( VkDevice                      device,
-                                   const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSignalSemaphoreKHR( device, pSignalInfo );
-    }
-
-    void vkTrimCommandPool( VkDevice               device,
-                            VkCommandPool          commandPool,
-                            VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkTrimCommandPool( device, commandPool, flags );
-    }
-
-    void vkTrimCommandPoolKHR( VkDevice               device,
-                               VkCommandPool          commandPool,
-                               VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkTrimCommandPoolKHR( device, commandPool, flags );
-    }
-
-    void vkUninitializePerformanceApiINTEL( VkDevice device ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUninitializePerformanceApiINTEL( device );
-    }
-
-    void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUnmapMemory( device, memory );
-    }
-
-    void vkUpdateDescriptorSetWithTemplate( VkDevice                   device,
-                                            VkDescriptorSet            descriptorSet,
-                                            VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-                                            const void *               pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData );
-    }
-
-    void vkUpdateDescriptorSetWithTemplateKHR( VkDevice                   device,
-                                               VkDescriptorSet            descriptorSet,
-                                               VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-                                               const void *               pData ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData );
-    }
-
-    void vkUpdateDescriptorSets( VkDevice                     device,
-                                 uint32_t                     descriptorWriteCount,
-                                 const VkWriteDescriptorSet * pDescriptorWrites,
-                                 uint32_t                     descriptorCopyCount,
-                                 const VkCopyDescriptorSet *  pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkUpdateDescriptorSets(
-        device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies );
-    }
-
-    VkResult vkWaitForFences( VkDevice        device,
-                              uint32_t        fenceCount,
-                              const VkFence * pFences,
-                              VkBool32        waitAll,
-                              uint64_t        timeout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
-    }
-
-    VkResult vkWaitSemaphores( VkDevice                    device,
-                               const VkSemaphoreWaitInfo * pWaitInfo,
-                               uint64_t                    timeout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkWaitSemaphores( device, pWaitInfo, timeout );
-    }
-
-    VkResult vkWaitSemaphoresKHR( VkDevice                    device,
-                                  const VkSemaphoreWaitInfo * pWaitInfo,
-                                  uint64_t                    timeout ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout );
-    }
-
-#  ifdef VK_ENABLE_BETA_EXTENSIONS
-    VkResult vkWriteAccelerationStructuresPropertiesKHR( VkDevice                           device,
-                                                         uint32_t                           accelerationStructureCount,
-                                                         const VkAccelerationStructureKHR * pAccelerationStructures,
-                                                         VkQueryType                        queryType,
-                                                         size_t                             dataSize,
-                                                         void *                             pData,
-                                                         size_t stride ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkWriteAccelerationStructuresPropertiesKHR(
-        device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride );
-    }
-#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-#  ifdef VK_USE_PLATFORM_ANDROID_KHR
-    VkResult vkCreateAndroidSurfaceKHR( VkInstance                            instance,
-                                        const VkAndroidSurfaceCreateInfoKHR * pCreateInfo,
-                                        const VkAllocationCallbacks *         pAllocator,
-                                        VkSurfaceKHR *                        pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      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 VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback );
-    }
-
-    VkResult vkCreateDebugUtilsMessengerEXT( VkInstance                                 instance,
-                                             const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,
-                                             const VkAllocationCallbacks *              pAllocator,
-                                             VkDebugUtilsMessengerEXT * pMessenger ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
-    }
-
-#  ifdef VK_USE_PLATFORM_DIRECTFB_EXT
-    VkResult vkCreateDirectFBSurfaceEXT( VkInstance                             instance,
-                                         const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,
-                                         const VkAllocationCallbacks *          pAllocator,
-                                         VkSurfaceKHR *                         pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
-    }
-#  endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-
-    VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance                            instance,
-                                             const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,
-                                             const VkAllocationCallbacks *         pAllocator,
-                                             VkSurfaceKHR *                        pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
-    }
-
-    VkResult vkCreateHeadlessSurfaceEXT( VkInstance                             instance,
-                                         const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo,
-                                         const VkAllocationCallbacks *          pAllocator,
-                                         VkSurfaceKHR *                         pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
-    }
-
-#  ifdef VK_USE_PLATFORM_IOS_MVK
-    VkResult vkCreateIOSSurfaceMVK( VkInstance                        instance,
-                                    const VkIOSSurfaceCreateInfoMVK * pCreateInfo,
-                                    const VkAllocationCallbacks *     pAllocator,
-                                    VkSurfaceKHR *                    pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
-    }
-#  endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#  ifdef VK_USE_PLATFORM_FUCHSIA
-    VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance                                  instance,
-                                              const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
-                                              const VkAllocationCallbacks *               pAllocator,
-                                              VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface );
-    }
-#  endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-#  ifdef VK_USE_PLATFORM_MACOS_MVK
-    VkResult vkCreateMacOSSurfaceMVK( VkInstance                          instance,
-                                      const VkMacOSSurfaceCreateInfoMVK * pCreateInfo,
-                                      const VkAllocationCallbacks *       pAllocator,
-                                      VkSurfaceKHR *                      pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
-    }
-#  endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-#  ifdef VK_USE_PLATFORM_METAL_EXT
-    VkResult vkCreateMetalSurfaceEXT( VkInstance                          instance,
-                                      const VkMetalSurfaceCreateInfoEXT * pCreateInfo,
-                                      const VkAllocationCallbacks *       pAllocator,
-                                      VkSurfaceKHR *                      pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
-    }
-#  endif /*VK_USE_PLATFORM_METAL_EXT*/
-
-#  ifdef VK_USE_PLATFORM_GGP
-    VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance                                     instance,
-                                                 const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
-                                                 const VkAllocationCallbacks *                  pAllocator,
-                                                 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface );
-    }
-#  endif /*VK_USE_PLATFORM_GGP*/
-
-#  ifdef VK_USE_PLATFORM_VI_NN
-    VkResult vkCreateViSurfaceNN( VkInstance                      instance,
-                                  const VkViSurfaceCreateInfoNN * pCreateInfo,
-                                  const VkAllocationCallbacks *   pAllocator,
-                                  VkSurfaceKHR *                  pSurface ) const VULKAN_HPP_NOEXCEPT
-    {
-      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 VULKAN_HPP_NOEXCEPT
-    {
-      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 VULKAN_HPP_NOEXCEPT
-    {
-      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 VULKAN_HPP_NOEXCEPT
-    {
-      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 VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
-    }
-#  endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-    void vkDebugReportMessageEXT( VkInstance                 instance,
-                                  VkDebugReportFlagsEXT      flags,
-                                  VkDebugReportObjectTypeEXT objectType,
-                                  uint64_t                   object,
-                                  size_t                     location,
-                                  int32_t                    messageCode,
-                                  const char *               pLayerPrefix,
-                                  const char *               pMessage ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDebugReportMessageEXT(
-        instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage );
-    }
-
-    void vkDestroyDebugReportCallbackEXT( VkInstance                    instance,
-                                          VkDebugReportCallbackEXT      callback,
-                                          const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator );
-    }
-
-    void vkDestroyDebugUtilsMessengerEXT( VkInstance                    instance,
-                                          VkDebugUtilsMessengerEXT      messenger,
-                                          const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
-    }
-
-    void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroyInstance( instance, pAllocator );
-    }
-
-    void vkDestroySurfaceKHR( VkInstance                    instance,
-                              VkSurfaceKHR                  surface,
-                              const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkDestroySurfaceKHR( instance, surface, pAllocator );
-    }
-
-    VkResult vkEnumeratePhysicalDeviceGroups( VkInstance                        instance,
-                                              uint32_t *                        pPhysicalDeviceGroupCount,
-                                              VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
-    }
-
-    VkResult vkEnumeratePhysicalDeviceGroupsKHR(
-      VkInstance                        instance,
-      uint32_t *                        pPhysicalDeviceGroupCount,
-      VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumeratePhysicalDeviceGroupsKHR(
-        instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
-    }
-
-    VkResult vkEnumeratePhysicalDevices( VkInstance         instance,
-                                         uint32_t *         pPhysicalDeviceCount,
-                                         VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices );
-    }
-
-    PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetInstanceProcAddr( instance, pName );
-    }
-
-    void vkSubmitDebugUtilsMessageEXT( VkInstance                                   instance,
-                                       VkDebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
-                                       VkDebugUtilsMessageTypeFlagsEXT              messageTypes,
-                                       const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData );
-    }
-
-#  ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice,
-                                      Display *        dpy,
-                                      VkDisplayKHR     display ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display );
-    }
-#  endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-    VkResult vkCreateDevice( VkPhysicalDevice              physicalDevice,
-                             const VkDeviceCreateInfo *    pCreateInfo,
-                             const VkAllocationCallbacks * pAllocator,
-                             VkDevice *                    pDevice ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice );
-    }
-
-    VkResult vkCreateDisplayModeKHR( VkPhysicalDevice                   physicalDevice,
-                                     VkDisplayKHR                       display,
-                                     const VkDisplayModeCreateInfoKHR * pCreateInfo,
-                                     const VkAllocationCallbacks *      pAllocator,
-                                     VkDisplayModeKHR *                 pMode ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode );
-    }
-
-    VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice        physicalDevice,
-                                                   const char *            pLayerName,
-                                                   uint32_t *              pPropertyCount,
-                                                   VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties );
-    }
-
-    VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice    physicalDevice,
-                                               uint32_t *          pPropertyCount,
-                                               VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
-    }
-
-    VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-      VkPhysicalDevice                     physicalDevice,
-      uint32_t                             queueFamilyIndex,
-      uint32_t *                           pCounterCount,
-      VkPerformanceCounterKHR *            pCounters,
-      VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
-        physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions );
-    }
-
-    VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice              physicalDevice,
-                                             VkDisplayKHR                  display,
-                                             uint32_t *                    pPropertyCount,
-                                             VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
-    }
-
-    VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice             physicalDevice,
-                                            VkDisplayKHR                 display,
-                                            uint32_t *                   pPropertyCount,
-                                            VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties );
-    }
-
-    VkResult
-      vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice                 physicalDevice,
-                                         const VkDisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
-                                         VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities );
-    }
-
-    VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice                physicalDevice,
-                                               VkDisplayModeKHR                mode,
-                                               uint32_t                        planeIndex,
-                                               VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities );
-    }
-
-    VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice,
-                                                    uint32_t         planeIndex,
-                                                    uint32_t *       pDisplayCount,
-                                                    VkDisplayKHR *   pDisplays ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays );
-    }
-
     VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice  physicalDevice,
                                                              uint32_t *        pTimeDomainCount,
                                                              VkTimeDomainEXT * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
@@ -4717,6 +4243,70 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VK_USE_PLATFORM_XLIB_KHR*/
 
+    VkResult vkGetPipelineCacheData( VkDevice        device,
+                                     VkPipelineCache pipelineCache,
+                                     size_t *        pDataSize,
+                                     void *          pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
+    }
+
+    VkResult vkGetPipelineExecutableInternalRepresentationsKHR(
+      VkDevice                                        device,
+      const VkPipelineExecutableInfoKHR *             pExecutableInfo,
+      uint32_t *                                      pInternalRepresentationCount,
+      VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPipelineExecutableInternalRepresentationsKHR(
+        device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations );
+    }
+
+    VkResult
+      vkGetPipelineExecutablePropertiesKHR( VkDevice                            device,
+                                            const VkPipelineInfoKHR *           pPipelineInfo,
+                                            uint32_t *                          pExecutableCount,
+                                            VkPipelineExecutablePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties );
+    }
+
+    VkResult
+      vkGetPipelineExecutableStatisticsKHR( VkDevice                            device,
+                                            const VkPipelineExecutableInfoKHR * pExecutableInfo,
+                                            uint32_t *                          pStatisticCount,
+                                            VkPipelineExecutableStatisticKHR *  pStatistics ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics );
+    }
+
+    void vkGetPrivateDataEXT( VkDevice             device,
+                              VkObjectType         objectType,
+                              uint64_t             objectHandle,
+                              VkPrivateDataSlotEXT privateDataSlot,
+                              uint64_t *           pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, pData );
+    }
+
+    VkResult vkGetQueryPoolResults( VkDevice           device,
+                                    VkQueryPool        queryPool,
+                                    uint32_t           firstQuery,
+                                    uint32_t           queryCount,
+                                    size_t             dataSize,
+                                    void *             pData,
+                                    VkDeviceSize       stride,
+                                    VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
+    }
+
+    void vkGetQueueCheckpointDataNV( VkQueue              queue,
+                                     uint32_t *           pCheckpointDataCount,
+                                     VkCheckpointDataNV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData );
+    }
+
 #  ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice,
                                          Display *        dpy,
@@ -4727,16 +4317,191 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
 
-    VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+#  ifdef VK_ENABLE_BETA_EXTENSIONS
+    VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( VkDevice   device,
+                                                                VkPipeline pipeline,
+                                                                uint32_t   firstGroup,
+                                                                uint32_t   groupCount,
+                                                                size_t     dataSize,
+                                                                void *     pData ) const VULKAN_HPP_NOEXCEPT
     {
-      return ::vkReleaseDisplayEXT( physicalDevice, display );
+      return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+        device, pipeline, firstGroup, groupCount, dataSize, pData );
+    }
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#  ifdef VK_ENABLE_BETA_EXTENSIONS
+    VkResult vkGetRayTracingShaderGroupHandlesKHR( VkDevice   device,
+                                                   VkPipeline pipeline,
+                                                   uint32_t   firstGroup,
+                                                   uint32_t   groupCount,
+                                                   size_t     dataSize,
+                                                   void *     pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
+    }
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+    VkResult vkGetRayTracingShaderGroupHandlesNV( VkDevice   device,
+                                                  VkPipeline pipeline,
+                                                  uint32_t   firstGroup,
+                                                  uint32_t   groupCount,
+                                                  size_t     dataSize,
+                                                  void *     pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData );
     }
 
-    void vkGetQueueCheckpointDataNV( VkQueue              queue,
-                                     uint32_t *           pCheckpointDataCount,
-                                     VkCheckpointDataNV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
+    VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice                       device,
+                                              VkSwapchainKHR                 swapchain,
+                                              VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties ) const
+      VULKAN_HPP_NOEXCEPT
     {
-      return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData );
+      return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties );
+    }
+
+    void vkGetRenderAreaGranularity( VkDevice     device,
+                                     VkRenderPass renderPass,
+                                     VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
+    }
+
+    VkResult
+      vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSemaphoreCounterValue( device, semaphore, pValue );
+    }
+
+    VkResult vkGetSemaphoreCounterValueKHR( VkDevice    device,
+                                            VkSemaphore semaphore,
+                                            uint64_t *  pValue ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue );
+    }
+
+    VkResult vkGetSemaphoreFdKHR( VkDevice                        device,
+                                  const VkSemaphoreGetFdInfoKHR * pGetFdInfo,
+                                  int *                           pFd ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
+    }
+
+#  ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkGetSemaphoreWin32HandleKHR( VkDevice                                 device,
+                                           const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
+                                           HANDLE *                                 pHandle ) const VULKAN_HPP_NOEXCEPT
+    {
+      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 VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo );
+    }
+
+    VkResult vkGetSwapchainCounterEXT( VkDevice                    device,
+                                       VkSwapchainKHR              swapchain,
+                                       VkSurfaceCounterFlagBitsEXT counter,
+                                       uint64_t *                  pCounterValue ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue );
+    }
+
+    VkResult vkGetSwapchainImagesKHR( VkDevice       device,
+                                      VkSwapchainKHR swapchain,
+                                      uint32_t *     pSwapchainImageCount,
+                                      VkImage *      pSwapchainImages ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages );
+    }
+
+    VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetSwapchainStatusKHR( device, swapchain );
+    }
+
+    VkResult vkGetValidationCacheDataEXT( VkDevice             device,
+                                          VkValidationCacheEXT validationCache,
+                                          size_t *             pDataSize,
+                                          void *               pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
+    }
+
+    VkResult vkImportFenceFdKHR( VkDevice                       device,
+                                 const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
+    }
+
+#  ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkImportFenceWin32HandleKHR(
+      VkDevice device, const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult
+      vkImportSemaphoreFdKHR( VkDevice                           device,
+                              const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo );
+    }
+
+#  ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkImportSemaphoreWin32HandleKHR(
+      VkDevice                                    device,
+      const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult vkInitializePerformanceApiINTEL(
+      VkDevice device, const VkInitializePerformanceApiInfoINTEL * pInitializeInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo );
+    }
+
+    VkResult vkInvalidateMappedMemoryRanges( VkDevice                    device,
+                                             uint32_t                    memoryRangeCount,
+                                             const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
+    }
+
+    VkResult vkMapMemory( VkDevice         device,
+                          VkDeviceMemory   memory,
+                          VkDeviceSize     offset,
+                          VkDeviceSize     size,
+                          VkMemoryMapFlags flags,
+                          void **          ppData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkMapMemory( device, memory, offset, size, flags, ppData );
+    }
+
+    VkResult vkMergePipelineCaches( VkDevice                device,
+                                    VkPipelineCache         dstCache,
+                                    uint32_t                srcCacheCount,
+                                    const VkPipelineCache * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches );
+    }
+
+    VkResult vkMergeValidationCachesEXT( VkDevice                     device,
+                                         VkValidationCacheEXT         dstCache,
+                                         uint32_t                     srcCacheCount,
+                                         const VkValidationCacheEXT * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches );
     }
 
     void vkQueueBeginDebugUtilsLabelEXT( VkQueue                      queue,
@@ -4788,6 +4553,241 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return ::vkQueueWaitIdle( queue );
     }
+
+    VkResult vkRegisterDeviceEventEXT( VkDevice                      device,
+                                       const VkDeviceEventInfoEXT *  pDeviceEventInfo,
+                                       const VkAllocationCallbacks * pAllocator,
+                                       VkFence *                     pFence ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence );
+    }
+
+    VkResult vkRegisterDisplayEventEXT( VkDevice                      device,
+                                        VkDisplayKHR                  display,
+                                        const VkDisplayEventInfoEXT * pDisplayEventInfo,
+                                        const VkAllocationCallbacks * pAllocator,
+                                        VkFence *                     pFence ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence );
+    }
+
+    VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkReleaseDisplayEXT( physicalDevice, display );
+    }
+
+#  ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+    VkResult
+      vkReleasePerformanceConfigurationINTEL( VkDevice                        device,
+                                              VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkReleasePerformanceConfigurationINTEL( device, configuration );
+    }
+
+    void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkReleaseProfilingLockKHR( device );
+    }
+
+    VkResult vkResetCommandBuffer( VkCommandBuffer           commandBuffer,
+                                   VkCommandBufferResetFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetCommandBuffer( commandBuffer, flags );
+    }
+
+    VkResult vkResetCommandPool( VkDevice                device,
+                                 VkCommandPool           commandPool,
+                                 VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetCommandPool( device, commandPool, flags );
+    }
+
+    VkResult vkResetDescriptorPool( VkDevice                   device,
+                                    VkDescriptorPool           descriptorPool,
+                                    VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetDescriptorPool( device, descriptorPool, flags );
+    }
+
+    VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetEvent( device, event );
+    }
+
+    VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetFences( device, fenceCount, pFences );
+    }
+
+    void vkResetQueryPool( VkDevice    device,
+                           VkQueryPool queryPool,
+                           uint32_t    firstQuery,
+                           uint32_t    queryCount ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount );
+    }
+
+    void vkResetQueryPoolEXT( VkDevice    device,
+                              VkQueryPool queryPool,
+                              uint32_t    firstQuery,
+                              uint32_t    queryCount ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount );
+    }
+
+    VkResult vkSetDebugUtilsObjectNameEXT( VkDevice                              device,
+                                           const VkDebugUtilsObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo );
+    }
+
+    VkResult vkSetDebugUtilsObjectTagEXT( VkDevice                             device,
+                                          const VkDebugUtilsObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo );
+    }
+
+    VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetEvent( device, event );
+    }
+
+    void vkSetHdrMetadataEXT( VkDevice                 device,
+                              uint32_t                 swapchainCount,
+                              const VkSwapchainKHR *   pSwapchains,
+                              const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata );
+    }
+
+    void vkSetLocalDimmingAMD( VkDevice       device,
+                               VkSwapchainKHR swapChain,
+                               VkBool32       localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable );
+    }
+
+    VkResult vkSetPrivateDataEXT( VkDevice             device,
+                                  VkObjectType         objectType,
+                                  uint64_t             objectHandle,
+                                  VkPrivateDataSlotEXT privateDataSlot,
+                                  uint64_t             data ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, data );
+    }
+
+    VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSignalSemaphore( device, pSignalInfo );
+    }
+
+    VkResult vkSignalSemaphoreKHR( VkDevice                      device,
+                                   const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSignalSemaphoreKHR( device, pSignalInfo );
+    }
+
+    void vkSubmitDebugUtilsMessageEXT( VkInstance                                   instance,
+                                       VkDebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
+                                       VkDebugUtilsMessageTypeFlagsEXT              messageTypes,
+                                       const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData );
+    }
+
+    void vkTrimCommandPool( VkDevice               device,
+                            VkCommandPool          commandPool,
+                            VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkTrimCommandPool( device, commandPool, flags );
+    }
+
+    void vkTrimCommandPoolKHR( VkDevice               device,
+                               VkCommandPool          commandPool,
+                               VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkTrimCommandPoolKHR( device, commandPool, flags );
+    }
+
+    void vkUninitializePerformanceApiINTEL( VkDevice device ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkUninitializePerformanceApiINTEL( device );
+    }
+
+    void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkUnmapMemory( device, memory );
+    }
+
+    void vkUpdateDescriptorSetWithTemplate( VkDevice                   device,
+                                            VkDescriptorSet            descriptorSet,
+                                            VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                            const void *               pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData );
+    }
+
+    void vkUpdateDescriptorSetWithTemplateKHR( VkDevice                   device,
+                                               VkDescriptorSet            descriptorSet,
+                                               VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                               const void *               pData ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData );
+    }
+
+    void vkUpdateDescriptorSets( VkDevice                     device,
+                                 uint32_t                     descriptorWriteCount,
+                                 const VkWriteDescriptorSet * pDescriptorWrites,
+                                 uint32_t                     descriptorCopyCount,
+                                 const VkCopyDescriptorSet *  pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkUpdateDescriptorSets(
+        device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies );
+    }
+
+    VkResult vkWaitForFences( VkDevice        device,
+                              uint32_t        fenceCount,
+                              const VkFence * pFences,
+                              VkBool32        waitAll,
+                              uint64_t        timeout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
+    }
+
+    VkResult vkWaitSemaphores( VkDevice                    device,
+                               const VkSemaphoreWaitInfo * pWaitInfo,
+                               uint64_t                    timeout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkWaitSemaphores( device, pWaitInfo, timeout );
+    }
+
+    VkResult vkWaitSemaphoresKHR( VkDevice                    device,
+                                  const VkSemaphoreWaitInfo * pWaitInfo,
+                                  uint64_t                    timeout ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout );
+    }
+
+#  ifdef VK_ENABLE_BETA_EXTENSIONS
+    VkResult vkWriteAccelerationStructuresPropertiesKHR( VkDevice                           device,
+                                                         uint32_t                           accelerationStructureCount,
+                                                         const VkAccelerationStructureKHR * pAccelerationStructures,
+                                                         VkQueryType                        queryType,
+                                                         size_t                             dataSize,
+                                                         void *                             pData,
+                                                         size_t stride ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkWriteAccelerationStructuresPropertiesKHR(
+        device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride );
+    }
+#  endif /*VK_ENABLE_BETA_EXTENSIONS*/
   };
 #endif
 
@@ -51408,17 +51408,6 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
-                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
-                  Optional<const AllocationCallbacks> allocator  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
@@ -51432,6 +51421,17 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
+                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
+                  Optional<const AllocationCallbacks> allocator  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
@@ -51513,7 +51513,9 @@ namespace VULKAN_HPP_NAMESPACE
       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
 
+#ifdef VK_ENABLE_BETA_EXTENSIONS
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
@@ -51586,17 +51588,6 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
-                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-                  Optional<const AllocationCallbacks> allocator  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
@@ -51610,6 +51601,17 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
+                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+                  Optional<const AllocationCallbacks> allocator  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
@@ -51926,17 +51928,6 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
-                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion  ycbcrConversion,
-                  Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
@@ -51950,6 +51941,17 @@ namespace VULKAN_HPP_NAMESPACE
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
+                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion  ycbcrConversion,
+                  Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
@@ -93292,6 +93294,30 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
 
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
+                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyAccelerationStructureNV( m_device,
+                                        static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
+                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
+                                            Optional<const AllocationCallbacks>            allocator,
+                                            Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroyAccelerationStructureNV(
+      m_device,
+      static_cast<VkAccelerationStructureKHR>( 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( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
@@ -93327,30 +93353,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
-                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyAccelerationStructureNV( m_device,
-                                        static_cast<VkAccelerationStructureKHR>( accelerationStructure ),
-                                        reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void
-    Device::destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
-                                            Optional<const AllocationCallbacks>            allocator,
-                                            Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroyAccelerationStructureNV(
-      m_device,
-      static_cast<VkAccelerationStructureKHR>( 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( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
@@ -93504,7 +93506,9 @@ namespace VULKAN_HPP_NAMESPACE
       reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
   }
 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_ENABLE_BETA_EXTENSIONS*/
 
+#ifdef VK_ENABLE_BETA_EXTENSIONS
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
@@ -93642,28 +93646,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    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( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
-                                          Optional<const AllocationCallbacks>            allocator,
-                                          Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
-  {
-    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( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
@@ -93688,6 +93670,28 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    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( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
+                                          Optional<const AllocationCallbacks>            allocator,
+                                          Dispatch const &                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    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( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
                                           Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
@@ -94290,28 +94294,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
-                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
-                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySamplerYcbcrConversion( m_device,
-                                       static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
-                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
-                                          Optional<const AllocationCallbacks>          allocator,
-                                          Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
-  {
-    d.vkDestroySamplerYcbcrConversion(
-      m_device,
-      static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
-      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
     Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
@@ -94336,6 +94318,28 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySamplerYcbcrConversion( m_device,
+                                       static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
+                                          Optional<const AllocationCallbacks>          allocator,
+                                          Dispatch const &                             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkDestroySamplerYcbcrConversion(
+      m_device,
+      static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
+      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template <typename Dispatch>
   VULKAN_HPP_INLINE void Device::destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
@@ -102670,7 +102674,6 @@ namespace VULKAN_HPP_NAMESPACE
     return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   template <>
   struct StructExtends<AndroidHardwareBufferFormatPropertiesANDROID, AndroidHardwareBufferPropertiesANDROID>
@@ -105474,28 +105477,50 @@ namespace VULKAN_HPP_NAMESPACE
   class DispatchLoaderDynamic
   {
   public:
-    PFN_vkCreateInstance                       vkCreateInstance                       = 0;
-    PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0;
-    PFN_vkEnumerateInstanceLayerProperties     vkEnumerateInstanceLayerProperties     = 0;
-    PFN_vkEnumerateInstanceVersion             vkEnumerateInstanceVersion             = 0;
-    PFN_vkBeginCommandBuffer                   vkBeginCommandBuffer                   = 0;
-    PFN_vkCmdBeginConditionalRenderingEXT      vkCmdBeginConditionalRenderingEXT      = 0;
-    PFN_vkCmdBeginDebugUtilsLabelEXT           vkCmdBeginDebugUtilsLabelEXT           = 0;
-    PFN_vkCmdBeginQuery                        vkCmdBeginQuery                        = 0;
-    PFN_vkCmdBeginQueryIndexedEXT              vkCmdBeginQueryIndexedEXT              = 0;
-    PFN_vkCmdBeginRenderPass                   vkCmdBeginRenderPass                   = 0;
-    PFN_vkCmdBeginRenderPass2                  vkCmdBeginRenderPass2                  = 0;
-    PFN_vkCmdBeginRenderPass2KHR               vkCmdBeginRenderPass2KHR               = 0;
-    PFN_vkCmdBeginTransformFeedbackEXT         vkCmdBeginTransformFeedbackEXT         = 0;
-    PFN_vkCmdBindDescriptorSets                vkCmdBindDescriptorSets                = 0;
-    PFN_vkCmdBindIndexBuffer                   vkCmdBindIndexBuffer                   = 0;
-    PFN_vkCmdBindPipeline                      vkCmdBindPipeline                      = 0;
-    PFN_vkCmdBindPipelineShaderGroupNV         vkCmdBindPipelineShaderGroupNV         = 0;
-    PFN_vkCmdBindShadingRateImageNV            vkCmdBindShadingRateImageNV            = 0;
-    PFN_vkCmdBindTransformFeedbackBuffersEXT   vkCmdBindTransformFeedbackBuffersEXT   = 0;
-    PFN_vkCmdBindVertexBuffers                 vkCmdBindVertexBuffers                 = 0;
-    PFN_vkCmdBindVertexBuffers2EXT             vkCmdBindVertexBuffers2EXT             = 0;
-    PFN_vkCmdBlitImage                         vkCmdBlitImage                         = 0;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+    PFN_vkAcquireNextImage2KHR                 vkAcquireNextImage2KHR                 = 0;
+    PFN_vkAcquireNextImageKHR                  vkAcquireNextImageKHR                  = 0;
+    PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0;
+    PFN_vkAcquireProfilingLockKHR              vkAcquireProfilingLockKHR              = 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_vkBeginCommandBuffer                vkBeginCommandBuffer                = 0;
+    PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkBindAccelerationStructureMemoryKHR vkBindAccelerationStructureMemoryKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    PFN_vkBindBufferMemory     vkBindBufferMemory     = 0;
+    PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0;
+    PFN_vkBindBufferMemory2    vkBindBufferMemory2    = 0;
+    PFN_vkBindImageMemory      vkBindImageMemory      = 0;
+    PFN_vkBindImageMemory2KHR  vkBindImageMemory2KHR  = 0;
+    PFN_vkBindImageMemory2     vkBindImageMemory2     = 0;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkBuildAccelerationStructureKHR vkBuildAccelerationStructureKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    PFN_vkCmdBeginConditionalRenderingEXT    vkCmdBeginConditionalRenderingEXT    = 0;
+    PFN_vkCmdBeginDebugUtilsLabelEXT         vkCmdBeginDebugUtilsLabelEXT         = 0;
+    PFN_vkCmdBeginQuery                      vkCmdBeginQuery                      = 0;
+    PFN_vkCmdBeginQueryIndexedEXT            vkCmdBeginQueryIndexedEXT            = 0;
+    PFN_vkCmdBeginRenderPass                 vkCmdBeginRenderPass                 = 0;
+    PFN_vkCmdBeginRenderPass2KHR             vkCmdBeginRenderPass2KHR             = 0;
+    PFN_vkCmdBeginRenderPass2                vkCmdBeginRenderPass2                = 0;
+    PFN_vkCmdBeginTransformFeedbackEXT       vkCmdBeginTransformFeedbackEXT       = 0;
+    PFN_vkCmdBindDescriptorSets              vkCmdBindDescriptorSets              = 0;
+    PFN_vkCmdBindIndexBuffer                 vkCmdBindIndexBuffer                 = 0;
+    PFN_vkCmdBindPipeline                    vkCmdBindPipeline                    = 0;
+    PFN_vkCmdBindPipelineShaderGroupNV       vkCmdBindPipelineShaderGroupNV       = 0;
+    PFN_vkCmdBindShadingRateImageNV          vkCmdBindShadingRateImageNV          = 0;
+    PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0;
+    PFN_vkCmdBindVertexBuffers               vkCmdBindVertexBuffers               = 0;
+    PFN_vkCmdBindVertexBuffers2EXT           vkCmdBindVertexBuffers2EXT           = 0;
+    PFN_vkCmdBlitImage                       vkCmdBlitImage                       = 0;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
     PFN_vkCmdBuildAccelerationStructureIndirectKHR vkCmdBuildAccelerationStructureIndirectKHR = 0;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -105525,20 +105550,20 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkCmdDebugMarkerEndEXT                vkCmdDebugMarkerEndEXT                = 0;
     PFN_vkCmdDebugMarkerInsertEXT             vkCmdDebugMarkerInsertEXT             = 0;
     PFN_vkCmdDispatch                         vkCmdDispatch                         = 0;
-    PFN_vkCmdDispatchBase                     vkCmdDispatchBase                     = 0;
     PFN_vkCmdDispatchBaseKHR                  vkCmdDispatchBaseKHR                  = 0;
+    PFN_vkCmdDispatchBase                     vkCmdDispatchBase                     = 0;
     PFN_vkCmdDispatchIndirect                 vkCmdDispatchIndirect                 = 0;
     PFN_vkCmdDraw                             vkCmdDraw                             = 0;
     PFN_vkCmdDrawIndexed                      vkCmdDrawIndexed                      = 0;
     PFN_vkCmdDrawIndexedIndirect              vkCmdDrawIndexedIndirect              = 0;
-    PFN_vkCmdDrawIndexedIndirectCount         vkCmdDrawIndexedIndirectCount         = 0;
     PFN_vkCmdDrawIndexedIndirectCountAMD      vkCmdDrawIndexedIndirectCountAMD      = 0;
     PFN_vkCmdDrawIndexedIndirectCountKHR      vkCmdDrawIndexedIndirectCountKHR      = 0;
+    PFN_vkCmdDrawIndexedIndirectCount         vkCmdDrawIndexedIndirectCount         = 0;
     PFN_vkCmdDrawIndirect                     vkCmdDrawIndirect                     = 0;
     PFN_vkCmdDrawIndirectByteCountEXT         vkCmdDrawIndirectByteCountEXT         = 0;
-    PFN_vkCmdDrawIndirectCount                vkCmdDrawIndirectCount                = 0;
     PFN_vkCmdDrawIndirectCountAMD             vkCmdDrawIndirectCountAMD             = 0;
     PFN_vkCmdDrawIndirectCountKHR             vkCmdDrawIndirectCountKHR             = 0;
+    PFN_vkCmdDrawIndirectCount                vkCmdDrawIndirectCount                = 0;
     PFN_vkCmdDrawMeshTasksIndirectCountNV     vkCmdDrawMeshTasksIndirectCountNV     = 0;
     PFN_vkCmdDrawMeshTasksIndirectNV          vkCmdDrawMeshTasksIndirectNV          = 0;
     PFN_vkCmdDrawMeshTasksNV                  vkCmdDrawMeshTasksNV                  = 0;
@@ -105547,16 +105572,16 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkCmdEndQuery                         vkCmdEndQuery                         = 0;
     PFN_vkCmdEndQueryIndexedEXT               vkCmdEndQueryIndexedEXT               = 0;
     PFN_vkCmdEndRenderPass                    vkCmdEndRenderPass                    = 0;
-    PFN_vkCmdEndRenderPass2                   vkCmdEndRenderPass2                   = 0;
     PFN_vkCmdEndRenderPass2KHR                vkCmdEndRenderPass2KHR                = 0;
+    PFN_vkCmdEndRenderPass2                   vkCmdEndRenderPass2                   = 0;
     PFN_vkCmdEndTransformFeedbackEXT          vkCmdEndTransformFeedbackEXT          = 0;
     PFN_vkCmdExecuteCommands                  vkCmdExecuteCommands                  = 0;
     PFN_vkCmdExecuteGeneratedCommandsNV       vkCmdExecuteGeneratedCommandsNV       = 0;
     PFN_vkCmdFillBuffer                       vkCmdFillBuffer                       = 0;
     PFN_vkCmdInsertDebugUtilsLabelEXT         vkCmdInsertDebugUtilsLabelEXT         = 0;
     PFN_vkCmdNextSubpass                      vkCmdNextSubpass                      = 0;
-    PFN_vkCmdNextSubpass2                     vkCmdNextSubpass2                     = 0;
     PFN_vkCmdNextSubpass2KHR                  vkCmdNextSubpass2KHR                  = 0;
+    PFN_vkCmdNextSubpass2                     vkCmdNextSubpass2                     = 0;
     PFN_vkCmdPipelineBarrier                  vkCmdPipelineBarrier                  = 0;
     PFN_vkCmdPreprocessGeneratedCommandsNV    vkCmdPreprocessGeneratedCommandsNV    = 0;
     PFN_vkCmdPushConstants                    vkCmdPushConstants                    = 0;
@@ -105575,8 +105600,8 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkCmdSetDepthCompareOpEXT             vkCmdSetDepthCompareOpEXT             = 0;
     PFN_vkCmdSetDepthTestEnableEXT            vkCmdSetDepthTestEnableEXT            = 0;
     PFN_vkCmdSetDepthWriteEnableEXT           vkCmdSetDepthWriteEnableEXT           = 0;
-    PFN_vkCmdSetDeviceMask                    vkCmdSetDeviceMask                    = 0;
     PFN_vkCmdSetDeviceMaskKHR                 vkCmdSetDeviceMaskKHR                 = 0;
+    PFN_vkCmdSetDeviceMask                    vkCmdSetDeviceMask                    = 0;
     PFN_vkCmdSetDiscardRectangleEXT           vkCmdSetDiscardRectangleEXT           = 0;
     PFN_vkCmdSetEvent                         vkCmdSetEvent                         = 0;
     PFN_vkCmdSetExclusiveScissorNV            vkCmdSetExclusiveScissorNV            = 0;
@@ -105605,41 +105630,16 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_ENABLE_BETA_EXTENSIONS
     PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    PFN_vkCmdTraceRaysNV  vkCmdTraceRaysNV  = 0;
-    PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0;
-    PFN_vkCmdWaitEvents   vkCmdWaitEvents   = 0;
+    PFN_vkCmdTraceRaysNV                             vkCmdTraceRaysNV                             = 0;
+    PFN_vkCmdUpdateBuffer                            vkCmdUpdateBuffer                            = 0;
+    PFN_vkCmdWaitEvents                              vkCmdWaitEvents                              = 0;
+    PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
     PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0;
-    PFN_vkCmdWriteBufferMarkerAMD                    vkCmdWriteBufferMarkerAMD                    = 0;
-    PFN_vkCmdWriteTimestamp                          vkCmdWriteTimestamp                          = 0;
-    PFN_vkEndCommandBuffer                           vkEndCommandBuffer                           = 0;
-    PFN_vkResetCommandBuffer                         vkResetCommandBuffer                         = 0;
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    PFN_vkAcquireNextImage2KHR                 vkAcquireNextImage2KHR                 = 0;
-    PFN_vkAcquireNextImageKHR                  vkAcquireNextImageKHR                  = 0;
-    PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0;
-    PFN_vkAcquireProfilingLockKHR              vkAcquireProfilingLockKHR              = 0;
-    PFN_vkAllocateCommandBuffers               vkAllocateCommandBuffers               = 0;
-    PFN_vkAllocateDescriptorSets               vkAllocateDescriptorSets               = 0;
-    PFN_vkAllocateMemory                       vkAllocateMemory                       = 0;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkBindAccelerationStructureMemoryKHR vkBindAccelerationStructureMemoryKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    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;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkBuildAccelerationStructureKHR vkBuildAccelerationStructureKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    PFN_vkCompileDeferredNV vkCompileDeferredNV = 0;
+    PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0;
+    PFN_vkCmdWriteTimestamp       vkCmdWriteTimestamp       = 0;
+    PFN_vkCompileDeferredNV       vkCompileDeferredNV       = 0;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
     PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -105653,264 +105653,71 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
     PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0;
-    PFN_vkCreateBuffer                  vkCreateBuffer                  = 0;
-    PFN_vkCreateBufferView              vkCreateBufferView              = 0;
-    PFN_vkCreateCommandPool             vkCreateCommandPool             = 0;
-    PFN_vkCreateComputePipelines        vkCreateComputePipelines        = 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;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
     PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
     PFN_vkCreateDescriptorPool              vkCreateDescriptorPool              = 0;
     PFN_vkCreateDescriptorSetLayout         vkCreateDescriptorSetLayout         = 0;
-    PFN_vkCreateDescriptorUpdateTemplate    vkCreateDescriptorUpdateTemplate    = 0;
     PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0;
-    PFN_vkCreateEvent                       vkCreateEvent                       = 0;
-    PFN_vkCreateFence                       vkCreateFence                       = 0;
-    PFN_vkCreateFramebuffer                 vkCreateFramebuffer                 = 0;
-    PFN_vkCreateGraphicsPipelines           vkCreateGraphicsPipelines           = 0;
-    PFN_vkCreateImage                       vkCreateImage                       = 0;
-    PFN_vkCreateImageView                   vkCreateImageView                   = 0;
-    PFN_vkCreateIndirectCommandsLayoutNV    vkCreateIndirectCommandsLayoutNV    = 0;
-    PFN_vkCreatePipelineCache               vkCreatePipelineCache               = 0;
-    PFN_vkCreatePipelineLayout              vkCreatePipelineLayout              = 0;
-    PFN_vkCreatePrivateDataSlotEXT          vkCreatePrivateDataSlotEXT          = 0;
-    PFN_vkCreateQueryPool                   vkCreateQueryPool                   = 0;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    PFN_vkCreateRayTracingPipelinesNV     vkCreateRayTracingPipelinesNV     = 0;
-    PFN_vkCreateRenderPass                vkCreateRenderPass                = 0;
-    PFN_vkCreateRenderPass2               vkCreateRenderPass2               = 0;
-    PFN_vkCreateRenderPass2KHR            vkCreateRenderPass2KHR            = 0;
-    PFN_vkCreateSampler                   vkCreateSampler                   = 0;
-    PFN_vkCreateSamplerYcbcrConversion    vkCreateSamplerYcbcrConversion    = 0;
-    PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0;
-    PFN_vkCreateSemaphore                 vkCreateSemaphore                 = 0;
-    PFN_vkCreateShaderModule              vkCreateShaderModule              = 0;
-    PFN_vkCreateSharedSwapchainsKHR       vkCreateSharedSwapchainsKHR       = 0;
-    PFN_vkCreateSwapchainKHR              vkCreateSwapchainKHR              = 0;
-    PFN_vkCreateValidationCacheEXT        vkCreateValidationCacheEXT        = 0;
-    PFN_vkDebugMarkerSetObjectNameEXT     vkDebugMarkerSetObjectNameEXT     = 0;
-    PFN_vkDebugMarkerSetObjectTagEXT      vkDebugMarkerSetObjectTagEXT      = 0;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0;
-    PFN_vkDestroyBuffer                  vkDestroyBuffer                  = 0;
-    PFN_vkDestroyBufferView              vkDestroyBufferView              = 0;
-    PFN_vkDestroyCommandPool             vkDestroyCommandPool             = 0;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    PFN_vkDestroyDescriptorPool              vkDestroyDescriptorPool              = 0;
-    PFN_vkDestroyDescriptorSetLayout         vkDestroyDescriptorSetLayout         = 0;
-    PFN_vkDestroyDescriptorUpdateTemplate    vkDestroyDescriptorUpdateTemplate    = 0;
-    PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0;
-    PFN_vkDestroyDevice                      vkDestroyDevice                      = 0;
-    PFN_vkDestroyEvent                       vkDestroyEvent                       = 0;
-    PFN_vkDestroyFence                       vkDestroyFence                       = 0;
-    PFN_vkDestroyFramebuffer                 vkDestroyFramebuffer                 = 0;
-    PFN_vkDestroyImage                       vkDestroyImage                       = 0;
-    PFN_vkDestroyImageView                   vkDestroyImageView                   = 0;
-    PFN_vkDestroyIndirectCommandsLayoutNV    vkDestroyIndirectCommandsLayoutNV    = 0;
-    PFN_vkDestroyPipeline                    vkDestroyPipeline                    = 0;
-    PFN_vkDestroyPipelineCache               vkDestroyPipelineCache               = 0;
-    PFN_vkDestroyPipelineLayout              vkDestroyPipelineLayout              = 0;
-    PFN_vkDestroyPrivateDataSlotEXT          vkDestroyPrivateDataSlotEXT          = 0;
-    PFN_vkDestroyQueryPool                   vkDestroyQueryPool                   = 0;
-    PFN_vkDestroyRenderPass                  vkDestroyRenderPass                  = 0;
-    PFN_vkDestroySampler                     vkDestroySampler                     = 0;
-    PFN_vkDestroySamplerYcbcrConversion      vkDestroySamplerYcbcrConversion      = 0;
-    PFN_vkDestroySamplerYcbcrConversionKHR   vkDestroySamplerYcbcrConversionKHR   = 0;
-    PFN_vkDestroySemaphore                   vkDestroySemaphore                   = 0;
-    PFN_vkDestroyShaderModule                vkDestroyShaderModule                = 0;
-    PFN_vkDestroySwapchainKHR                vkDestroySwapchainKHR                = 0;
-    PFN_vkDestroyValidationCacheEXT          vkDestroyValidationCacheEXT          = 0;
-    PFN_vkDeviceWaitIdle                     vkDeviceWaitIdle                     = 0;
-    PFN_vkDisplayPowerControlEXT             vkDisplayPowerControlEXT             = 0;
-    PFN_vkFlushMappedMemoryRanges            vkFlushMappedMemoryRanges            = 0;
-    PFN_vkFreeCommandBuffers                 vkFreeCommandBuffers                 = 0;
-    PFN_vkFreeDescriptorSets                 vkFreeDescriptorSets                 = 0;
-    PFN_vkFreeMemory                         vkFreeMemory                         = 0;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkGetAccelerationStructureMemoryRequirementsKHR vkGetAccelerationStructureMemoryRequirementsKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0;
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0;
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-    PFN_vkGetBufferDeviceAddress           vkGetBufferDeviceAddress           = 0;
-    PFN_vkGetBufferDeviceAddressEXT        vkGetBufferDeviceAddressEXT        = 0;
-    PFN_vkGetBufferDeviceAddressKHR        vkGetBufferDeviceAddressKHR        = 0;
-    PFN_vkGetBufferMemoryRequirements      vkGetBufferMemoryRequirements      = 0;
-    PFN_vkGetBufferMemoryRequirements2     vkGetBufferMemoryRequirements2     = 0;
-    PFN_vkGetBufferMemoryRequirements2KHR  vkGetBufferMemoryRequirements2KHR  = 0;
-    PFN_vkGetBufferOpaqueCaptureAddress    vkGetBufferOpaqueCaptureAddress    = 0;
-    PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0;
-    PFN_vkGetCalibratedTimestampsEXT       vkGetCalibratedTimestampsEXT       = 0;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    PFN_vkGetDescriptorSetLayoutSupport    vkGetDescriptorSetLayoutSupport    = 0;
-    PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    PFN_vkGetDeviceGroupPeerMemoryFeatures     vkGetDeviceGroupPeerMemoryFeatures     = 0;
-    PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR  vkGetDeviceGroupPeerMemoryFeaturesKHR  = 0;
-    PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0;
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    PFN_vkGetDeviceGroupSurfacePresentModesKHR   vkGetDeviceGroupSurfacePresentModesKHR   = 0;
-    PFN_vkGetDeviceMemoryCommitment              vkGetDeviceMemoryCommitment              = 0;
-    PFN_vkGetDeviceMemoryOpaqueCaptureAddress    vkGetDeviceMemoryOpaqueCaptureAddress    = 0;
-    PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0;
-    PFN_vkGetDeviceProcAddr                      vkGetDeviceProcAddr                      = 0;
-    PFN_vkGetDeviceQueue                         vkGetDeviceQueue                         = 0;
-    PFN_vkGetDeviceQueue2                        vkGetDeviceQueue2                        = 0;
-    PFN_vkGetEventStatus                         vkGetEventStatus                         = 0;
-    PFN_vkGetFenceFdKHR                          vkGetFenceFdKHR                          = 0;
-    PFN_vkGetFenceStatus                         vkGetFenceStatus                         = 0;
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0;
-    PFN_vkGetImageDrmFormatModifierPropertiesEXT   vkGetImageDrmFormatModifierPropertiesEXT   = 0;
-    PFN_vkGetImageMemoryRequirements               vkGetImageMemoryRequirements               = 0;
-    PFN_vkGetImageMemoryRequirements2              vkGetImageMemoryRequirements2              = 0;
-    PFN_vkGetImageMemoryRequirements2KHR           vkGetImageMemoryRequirements2KHR           = 0;
-    PFN_vkGetImageSparseMemoryRequirements         vkGetImageSparseMemoryRequirements         = 0;
-    PFN_vkGetImageSparseMemoryRequirements2        vkGetImageSparseMemoryRequirements2        = 0;
-    PFN_vkGetImageSparseMemoryRequirements2KHR     vkGetImageSparseMemoryRequirements2KHR     = 0;
-    PFN_vkGetImageSubresourceLayout                vkGetImageSubresourceLayout                = 0;
-    PFN_vkGetImageViewAddressNVX                   vkGetImageViewAddressNVX                   = 0;
-    PFN_vkGetImageViewHandleNVX                    vkGetImageViewHandleNVX                    = 0;
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0;
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-    PFN_vkGetMemoryFdKHR                    vkGetMemoryFdKHR                    = 0;
-    PFN_vkGetMemoryFdPropertiesKHR          vkGetMemoryFdPropertiesKHR          = 0;
-    PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0;
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    PFN_vkGetPastPresentationTimingGOOGLE                 vkGetPastPresentationTimingGOOGLE                 = 0;
-    PFN_vkGetPerformanceParameterINTEL                    vkGetPerformanceParameterINTEL                    = 0;
-    PFN_vkGetPipelineCacheData                            vkGetPipelineCacheData                            = 0;
-    PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0;
-    PFN_vkGetPipelineExecutablePropertiesKHR              vkGetPipelineExecutablePropertiesKHR              = 0;
-    PFN_vkGetPipelineExecutableStatisticsKHR              vkGetPipelineExecutableStatisticsKHR              = 0;
-    PFN_vkGetPrivateDataEXT                               vkGetPrivateDataEXT                               = 0;
-    PFN_vkGetQueryPoolResults                             vkGetQueryPoolResults                             = 0;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0;
-    PFN_vkGetRefreshCycleDurationGOOGLE     vkGetRefreshCycleDurationGOOGLE     = 0;
-    PFN_vkGetRenderAreaGranularity          vkGetRenderAreaGranularity          = 0;
-    PFN_vkGetSemaphoreCounterValue          vkGetSemaphoreCounterValue          = 0;
-    PFN_vkGetSemaphoreCounterValueKHR       vkGetSemaphoreCounterValueKHR       = 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_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0;
-    PFN_vkInvalidateMappedMemoryRanges  vkInvalidateMappedMemoryRanges  = 0;
-    PFN_vkMapMemory                     vkMapMemory                     = 0;
-    PFN_vkMergePipelineCaches           vkMergePipelineCaches           = 0;
-    PFN_vkMergeValidationCachesEXT      vkMergeValidationCachesEXT      = 0;
-    PFN_vkRegisterDeviceEventEXT        vkRegisterDeviceEventEXT        = 0;
-    PFN_vkRegisterDisplayEventEXT       vkRegisterDisplayEventEXT       = 0;
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-    PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0;
-    PFN_vkReleaseProfilingLockKHR              vkReleaseProfilingLockKHR              = 0;
-    PFN_vkResetCommandPool                     vkResetCommandPool                     = 0;
-    PFN_vkResetDescriptorPool                  vkResetDescriptorPool                  = 0;
-    PFN_vkResetEvent                           vkResetEvent                           = 0;
-    PFN_vkResetFences                          vkResetFences                          = 0;
-    PFN_vkResetQueryPool                       vkResetQueryPool                       = 0;
-    PFN_vkResetQueryPoolEXT                    vkResetQueryPoolEXT                    = 0;
-    PFN_vkSetDebugUtilsObjectNameEXT           vkSetDebugUtilsObjectNameEXT           = 0;
-    PFN_vkSetDebugUtilsObjectTagEXT            vkSetDebugUtilsObjectTagEXT            = 0;
-    PFN_vkSetEvent                             vkSetEvent                             = 0;
-    PFN_vkSetHdrMetadataEXT                    vkSetHdrMetadataEXT                    = 0;
-    PFN_vkSetLocalDimmingAMD                   vkSetLocalDimmingAMD                   = 0;
-    PFN_vkSetPrivateDataEXT                    vkSetPrivateDataEXT                    = 0;
-    PFN_vkSignalSemaphore                      vkSignalSemaphore                      = 0;
-    PFN_vkSignalSemaphoreKHR                   vkSignalSemaphoreKHR                   = 0;
-    PFN_vkTrimCommandPool                      vkTrimCommandPool                      = 0;
-    PFN_vkTrimCommandPoolKHR                   vkTrimCommandPoolKHR                   = 0;
-    PFN_vkUninitializePerformanceApiINTEL      vkUninitializePerformanceApiINTEL      = 0;
-    PFN_vkUnmapMemory                          vkUnmapMemory                          = 0;
-    PFN_vkUpdateDescriptorSetWithTemplate      vkUpdateDescriptorSetWithTemplate      = 0;
-    PFN_vkUpdateDescriptorSetWithTemplateKHR   vkUpdateDescriptorSetWithTemplateKHR   = 0;
-    PFN_vkUpdateDescriptorSets                 vkUpdateDescriptorSets                 = 0;
-    PFN_vkWaitForFences                        vkWaitForFences                        = 0;
-    PFN_vkWaitSemaphores                       vkWaitSemaphores                       = 0;
-    PFN_vkWaitSemaphoresKHR                    vkWaitSemaphoresKHR                    = 0;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0;
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-#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_vkCreateDescriptorUpdateTemplate    vkCreateDescriptorUpdateTemplate    = 0;
+    PFN_vkCreateDevice                      vkCreateDevice                      = 0;
 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
     PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0;
 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+    PFN_vkCreateDisplayModeKHR         vkCreateDisplayModeKHR         = 0;
     PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0;
+    PFN_vkCreateEvent                  vkCreateEvent                  = 0;
+    PFN_vkCreateFence                  vkCreateFence                  = 0;
+    PFN_vkCreateFramebuffer            vkCreateFramebuffer            = 0;
+    PFN_vkCreateGraphicsPipelines      vkCreateGraphicsPipelines      = 0;
     PFN_vkCreateHeadlessSurfaceEXT     vkCreateHeadlessSurfaceEXT     = 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_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0;
+    PFN_vkCreateInstance                 vkCreateInstance                 = 0;
 #ifdef VK_USE_PLATFORM_MACOS_MVK
     PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0;
 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
 #ifdef VK_USE_PLATFORM_METAL_EXT
     PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0;
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
+    PFN_vkCreatePipelineCache      vkCreatePipelineCache      = 0;
+    PFN_vkCreatePipelineLayout     vkCreatePipelineLayout     = 0;
+    PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0;
+    PFN_vkCreateQueryPool          vkCreateQueryPool          = 0;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    PFN_vkCreateRayTracingPipelinesNV     vkCreateRayTracingPipelinesNV     = 0;
+    PFN_vkCreateRenderPass                vkCreateRenderPass                = 0;
+    PFN_vkCreateRenderPass2KHR            vkCreateRenderPass2KHR            = 0;
+    PFN_vkCreateRenderPass2               vkCreateRenderPass2               = 0;
+    PFN_vkCreateSampler                   vkCreateSampler                   = 0;
+    PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0;
+    PFN_vkCreateSamplerYcbcrConversion    vkCreateSamplerYcbcrConversion    = 0;
+    PFN_vkCreateSemaphore                 vkCreateSemaphore                 = 0;
+    PFN_vkCreateShaderModule              vkCreateShaderModule              = 0;
+    PFN_vkCreateSharedSwapchainsKHR       vkCreateSharedSwapchainsKHR       = 0;
 #ifdef VK_USE_PLATFORM_GGP
     PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0;
 #endif /*VK_USE_PLATFORM_GGP*/
+    PFN_vkCreateSwapchainKHR       vkCreateSwapchainKHR       = 0;
+    PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0;
 #ifdef VK_USE_PLATFORM_VI_NN
     PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0;
 #endif /*VK_USE_PLATFORM_VI_NN*/
@@ -105926,30 +105733,151 @@ namespace VULKAN_HPP_NAMESPACE
 #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_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0;
+    PFN_vkDebugMarkerSetObjectTagEXT  vkDebugMarkerSetObjectTagEXT  = 0;
+    PFN_vkDebugReportMessageEXT       vkDebugReportMessageEXT       = 0;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    PFN_vkDestroyBuffer                 vkDestroyBuffer                 = 0;
+    PFN_vkDestroyBufferView             vkDestroyBufferView             = 0;
+    PFN_vkDestroyCommandPool            vkDestroyCommandPool            = 0;
+    PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0;
+    PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    PFN_vkDestroyDescriptorPool                vkDestroyDescriptorPool                = 0;
+    PFN_vkDestroyDescriptorSetLayout           vkDestroyDescriptorSetLayout           = 0;
+    PFN_vkDestroyDescriptorUpdateTemplateKHR   vkDestroyDescriptorUpdateTemplateKHR   = 0;
+    PFN_vkDestroyDescriptorUpdateTemplate      vkDestroyDescriptorUpdateTemplate      = 0;
+    PFN_vkDestroyDevice                        vkDestroyDevice                        = 0;
+    PFN_vkDestroyEvent                         vkDestroyEvent                         = 0;
+    PFN_vkDestroyFence                         vkDestroyFence                         = 0;
+    PFN_vkDestroyFramebuffer                   vkDestroyFramebuffer                   = 0;
+    PFN_vkDestroyImage                         vkDestroyImage                         = 0;
+    PFN_vkDestroyImageView                     vkDestroyImageView                     = 0;
+    PFN_vkDestroyIndirectCommandsLayoutNV      vkDestroyIndirectCommandsLayoutNV      = 0;
+    PFN_vkDestroyInstance                      vkDestroyInstance                      = 0;
+    PFN_vkDestroyPipeline                      vkDestroyPipeline                      = 0;
+    PFN_vkDestroyPipelineCache                 vkDestroyPipelineCache                 = 0;
+    PFN_vkDestroyPipelineLayout                vkDestroyPipelineLayout                = 0;
+    PFN_vkDestroyPrivateDataSlotEXT            vkDestroyPrivateDataSlotEXT            = 0;
+    PFN_vkDestroyQueryPool                     vkDestroyQueryPool                     = 0;
+    PFN_vkDestroyRenderPass                    vkDestroyRenderPass                    = 0;
+    PFN_vkDestroySampler                       vkDestroySampler                       = 0;
+    PFN_vkDestroySamplerYcbcrConversionKHR     vkDestroySamplerYcbcrConversionKHR     = 0;
+    PFN_vkDestroySamplerYcbcrConversion        vkDestroySamplerYcbcrConversion        = 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_vkEnumeratePhysicalDeviceGroupsKHR     vkEnumeratePhysicalDeviceGroupsKHR     = 0;
+    PFN_vkEnumeratePhysicalDeviceGroups        vkEnumeratePhysicalDeviceGroups        = 0;
     PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR
-                                                         vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0;
-    PFN_vkGetDisplayModeProperties2KHR                   vkGetDisplayModeProperties2KHR                   = 0;
-    PFN_vkGetDisplayModePropertiesKHR                    vkGetDisplayModePropertiesKHR                    = 0;
-    PFN_vkGetDisplayPlaneCapabilities2KHR                vkGetDisplayPlaneCapabilities2KHR                = 0;
-    PFN_vkGetDisplayPlaneCapabilitiesKHR                 vkGetDisplayPlaneCapabilitiesKHR                 = 0;
-    PFN_vkGetDisplayPlaneSupportedDisplaysKHR            vkGetDisplayPlaneSupportedDisplaysKHR            = 0;
+                                   vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0;
+    PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices                                      = 0;
+    PFN_vkFlushMappedMemoryRanges  vkFlushMappedMemoryRanges                                       = 0;
+    PFN_vkFreeCommandBuffers       vkFreeCommandBuffers                                            = 0;
+    PFN_vkFreeDescriptorSets       vkFreeDescriptorSets                                            = 0;
+    PFN_vkFreeMemory               vkFreeMemory                                                    = 0;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkGetAccelerationStructureMemoryRequirementsKHR vkGetAccelerationStructureMemoryRequirementsKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0;
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+    PFN_vkGetBufferDeviceAddressEXT        vkGetBufferDeviceAddressEXT        = 0;
+    PFN_vkGetBufferDeviceAddressKHR        vkGetBufferDeviceAddressKHR        = 0;
+    PFN_vkGetBufferDeviceAddress           vkGetBufferDeviceAddress           = 0;
+    PFN_vkGetBufferMemoryRequirements      vkGetBufferMemoryRequirements      = 0;
+    PFN_vkGetBufferMemoryRequirements2KHR  vkGetBufferMemoryRequirements2KHR  = 0;
+    PFN_vkGetBufferMemoryRequirements2     vkGetBufferMemoryRequirements2     = 0;
+    PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0;
+    PFN_vkGetBufferOpaqueCaptureAddress    vkGetBufferOpaqueCaptureAddress    = 0;
+    PFN_vkGetCalibratedTimestampsEXT       vkGetCalibratedTimestampsEXT       = 0;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0;
+    PFN_vkGetDescriptorSetLayoutSupport    vkGetDescriptorSetLayoutSupport    = 0;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR  vkGetDeviceGroupPeerMemoryFeaturesKHR  = 0;
+    PFN_vkGetDeviceGroupPeerMemoryFeatures     vkGetDeviceGroupPeerMemoryFeatures     = 0;
+    PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+    PFN_vkGetDeviceGroupSurfacePresentModesKHR   vkGetDeviceGroupSurfacePresentModesKHR   = 0;
+    PFN_vkGetDeviceMemoryCommitment              vkGetDeviceMemoryCommitment              = 0;
+    PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0;
+    PFN_vkGetDeviceMemoryOpaqueCaptureAddress    vkGetDeviceMemoryOpaqueCaptureAddress    = 0;
+    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;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+    PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0;
+    PFN_vkGetImageDrmFormatModifierPropertiesEXT   vkGetImageDrmFormatModifierPropertiesEXT   = 0;
+    PFN_vkGetImageMemoryRequirements               vkGetImageMemoryRequirements               = 0;
+    PFN_vkGetImageMemoryRequirements2KHR           vkGetImageMemoryRequirements2KHR           = 0;
+    PFN_vkGetImageMemoryRequirements2              vkGetImageMemoryRequirements2              = 0;
+    PFN_vkGetImageSparseMemoryRequirements         vkGetImageSparseMemoryRequirements         = 0;
+    PFN_vkGetImageSparseMemoryRequirements2KHR     vkGetImageSparseMemoryRequirements2KHR     = 0;
+    PFN_vkGetImageSparseMemoryRequirements2        vkGetImageSparseMemoryRequirements2        = 0;
+    PFN_vkGetImageSubresourceLayout                vkGetImageSubresourceLayout                = 0;
+    PFN_vkGetImageViewAddressNVX                   vkGetImageViewAddressNVX                   = 0;
+    PFN_vkGetImageViewHandleNVX                    vkGetImageViewHandleNVX                    = 0;
+    PFN_vkGetInstanceProcAddr                      vkGetInstanceProcAddr                      = 0;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0;
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+    PFN_vkGetMemoryFdKHR                    vkGetMemoryFdKHR                    = 0;
+    PFN_vkGetMemoryFdPropertiesKHR          vkGetMemoryFdPropertiesKHR          = 0;
+    PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+    PFN_vkGetPastPresentationTimingGOOGLE                vkGetPastPresentationTimingGOOGLE                = 0;
+    PFN_vkGetPerformanceParameterINTEL                   vkGetPerformanceParameterINTEL                   = 0;
     PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT   vkGetPhysicalDeviceCalibrateableTimeDomainsEXT   = 0;
     PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0;
 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
@@ -105959,38 +105887,38 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR       vkGetPhysicalDeviceDisplayPlanePropertiesKHR       = 0;
     PFN_vkGetPhysicalDeviceDisplayProperties2KHR           vkGetPhysicalDeviceDisplayProperties2KHR           = 0;
     PFN_vkGetPhysicalDeviceDisplayPropertiesKHR            vkGetPhysicalDeviceDisplayPropertiesKHR            = 0;
-    PFN_vkGetPhysicalDeviceExternalBufferProperties        vkGetPhysicalDeviceExternalBufferProperties        = 0;
     PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR     vkGetPhysicalDeviceExternalBufferPropertiesKHR     = 0;
-    PFN_vkGetPhysicalDeviceExternalFenceProperties         vkGetPhysicalDeviceExternalFenceProperties         = 0;
+    PFN_vkGetPhysicalDeviceExternalBufferProperties        vkGetPhysicalDeviceExternalBufferProperties        = 0;
     PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR      vkGetPhysicalDeviceExternalFencePropertiesKHR      = 0;
+    PFN_vkGetPhysicalDeviceExternalFenceProperties         vkGetPhysicalDeviceExternalFenceProperties         = 0;
     PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0;
-    PFN_vkGetPhysicalDeviceExternalSemaphoreProperties     vkGetPhysicalDeviceExternalSemaphoreProperties     = 0;
     PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR  vkGetPhysicalDeviceExternalSemaphorePropertiesKHR  = 0;
+    PFN_vkGetPhysicalDeviceExternalSemaphoreProperties     vkGetPhysicalDeviceExternalSemaphoreProperties     = 0;
     PFN_vkGetPhysicalDeviceFeatures                        vkGetPhysicalDeviceFeatures                        = 0;
-    PFN_vkGetPhysicalDeviceFeatures2                       vkGetPhysicalDeviceFeatures2                       = 0;
     PFN_vkGetPhysicalDeviceFeatures2KHR                    vkGetPhysicalDeviceFeatures2KHR                    = 0;
+    PFN_vkGetPhysicalDeviceFeatures2                       vkGetPhysicalDeviceFeatures2                       = 0;
     PFN_vkGetPhysicalDeviceFormatProperties                vkGetPhysicalDeviceFormatProperties                = 0;
-    PFN_vkGetPhysicalDeviceFormatProperties2               vkGetPhysicalDeviceFormatProperties2               = 0;
     PFN_vkGetPhysicalDeviceFormatProperties2KHR            vkGetPhysicalDeviceFormatProperties2KHR            = 0;
+    PFN_vkGetPhysicalDeviceFormatProperties2               vkGetPhysicalDeviceFormatProperties2               = 0;
     PFN_vkGetPhysicalDeviceImageFormatProperties           vkGetPhysicalDeviceImageFormatProperties           = 0;
-    PFN_vkGetPhysicalDeviceImageFormatProperties2          vkGetPhysicalDeviceImageFormatProperties2          = 0;
     PFN_vkGetPhysicalDeviceImageFormatProperties2KHR       vkGetPhysicalDeviceImageFormatProperties2KHR       = 0;
+    PFN_vkGetPhysicalDeviceImageFormatProperties2          vkGetPhysicalDeviceImageFormatProperties2          = 0;
     PFN_vkGetPhysicalDeviceMemoryProperties                vkGetPhysicalDeviceMemoryProperties                = 0;
-    PFN_vkGetPhysicalDeviceMemoryProperties2               vkGetPhysicalDeviceMemoryProperties2               = 0;
     PFN_vkGetPhysicalDeviceMemoryProperties2KHR            vkGetPhysicalDeviceMemoryProperties2KHR            = 0;
+    PFN_vkGetPhysicalDeviceMemoryProperties2               vkGetPhysicalDeviceMemoryProperties2               = 0;
     PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT        vkGetPhysicalDeviceMultisamplePropertiesEXT        = 0;
     PFN_vkGetPhysicalDevicePresentRectanglesKHR            vkGetPhysicalDevicePresentRectanglesKHR            = 0;
     PFN_vkGetPhysicalDeviceProperties                      vkGetPhysicalDeviceProperties                      = 0;
-    PFN_vkGetPhysicalDeviceProperties2                     vkGetPhysicalDeviceProperties2                     = 0;
     PFN_vkGetPhysicalDeviceProperties2KHR                  vkGetPhysicalDeviceProperties2KHR                  = 0;
+    PFN_vkGetPhysicalDeviceProperties2                     vkGetPhysicalDeviceProperties2                     = 0;
     PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR
                                                            vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0;
     PFN_vkGetPhysicalDeviceQueueFamilyProperties           vkGetPhysicalDeviceQueueFamilyProperties                = 0;
-    PFN_vkGetPhysicalDeviceQueueFamilyProperties2          vkGetPhysicalDeviceQueueFamilyProperties2               = 0;
     PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR       vkGetPhysicalDeviceQueueFamilyProperties2KHR            = 0;
+    PFN_vkGetPhysicalDeviceQueueFamilyProperties2          vkGetPhysicalDeviceQueueFamilyProperties2               = 0;
     PFN_vkGetPhysicalDeviceSparseImageFormatProperties     vkGetPhysicalDeviceSparseImageFormatProperties          = 0;
-    PFN_vkGetPhysicalDeviceSparseImageFormatProperties2    vkGetPhysicalDeviceSparseImageFormatProperties2         = 0;
     PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR      = 0;
+    PFN_vkGetPhysicalDeviceSparseImageFormatProperties2    vkGetPhysicalDeviceSparseImageFormatProperties2         = 0;
     PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV
                                                    vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0;
     PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0;
@@ -106016,11 +105944,49 @@ namespace VULKAN_HPP_NAMESPACE
 #ifdef VK_USE_PLATFORM_XLIB_KHR
     PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0;
 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
+    PFN_vkGetPipelineCacheData                            vkGetPipelineCacheData                            = 0;
+    PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0;
+    PFN_vkGetPipelineExecutablePropertiesKHR              vkGetPipelineExecutablePropertiesKHR              = 0;
+    PFN_vkGetPipelineExecutableStatisticsKHR              vkGetPipelineExecutableStatisticsKHR              = 0;
+    PFN_vkGetPrivateDataEXT                               vkGetPrivateDataEXT                               = 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_vkReleaseDisplayEXT                     vkReleaseDisplayEXT                     = 0;
-    PFN_vkGetQueueCheckpointDataNV              vkGetQueueCheckpointDataNV              = 0;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0;
+    PFN_vkGetRenderAreaGranularity      vkGetRenderAreaGranularity      = 0;
+    PFN_vkGetSemaphoreCounterValueKHR   vkGetSemaphoreCounterValueKHR   = 0;
+    PFN_vkGetSemaphoreCounterValue      vkGetSemaphoreCounterValue      = 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_vkInitializePerformanceApiINTEL         vkInitializePerformanceApiINTEL         = 0;
+    PFN_vkInvalidateMappedMemoryRanges          vkInvalidateMappedMemoryRanges          = 0;
+    PFN_vkMapMemory                             vkMapMemory                             = 0;
+    PFN_vkMergePipelineCaches                   vkMergePipelineCaches                   = 0;
+    PFN_vkMergeValidationCachesEXT              vkMergeValidationCachesEXT              = 0;
     PFN_vkQueueBeginDebugUtilsLabelEXT          vkQueueBeginDebugUtilsLabelEXT          = 0;
     PFN_vkQueueBindSparse                       vkQueueBindSparse                       = 0;
     PFN_vkQueueEndDebugUtilsLabelEXT            vkQueueEndDebugUtilsLabelEXT            = 0;
@@ -106029,6 +105995,43 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0;
     PFN_vkQueueSubmit                           vkQueueSubmit                           = 0;
     PFN_vkQueueWaitIdle                         vkQueueWaitIdle                         = 0;
+    PFN_vkRegisterDeviceEventEXT                vkRegisterDeviceEventEXT                = 0;
+    PFN_vkRegisterDisplayEventEXT               vkRegisterDisplayEventEXT               = 0;
+    PFN_vkReleaseDisplayEXT                     vkReleaseDisplayEXT                     = 0;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+    PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0;
+    PFN_vkReleaseProfilingLockKHR              vkReleaseProfilingLockKHR              = 0;
+    PFN_vkResetCommandBuffer                   vkResetCommandBuffer                   = 0;
+    PFN_vkResetCommandPool                     vkResetCommandPool                     = 0;
+    PFN_vkResetDescriptorPool                  vkResetDescriptorPool                  = 0;
+    PFN_vkResetEvent                           vkResetEvent                           = 0;
+    PFN_vkResetFences                          vkResetFences                          = 0;
+    PFN_vkResetQueryPoolEXT                    vkResetQueryPoolEXT                    = 0;
+    PFN_vkResetQueryPool                       vkResetQueryPool                       = 0;
+    PFN_vkSetDebugUtilsObjectNameEXT           vkSetDebugUtilsObjectNameEXT           = 0;
+    PFN_vkSetDebugUtilsObjectTagEXT            vkSetDebugUtilsObjectTagEXT            = 0;
+    PFN_vkSetEvent                             vkSetEvent                             = 0;
+    PFN_vkSetHdrMetadataEXT                    vkSetHdrMetadataEXT                    = 0;
+    PFN_vkSetLocalDimmingAMD                   vkSetLocalDimmingAMD                   = 0;
+    PFN_vkSetPrivateDataEXT                    vkSetPrivateDataEXT                    = 0;
+    PFN_vkSignalSemaphoreKHR                   vkSignalSemaphoreKHR                   = 0;
+    PFN_vkSignalSemaphore                      vkSignalSemaphore                      = 0;
+    PFN_vkSubmitDebugUtilsMessageEXT           vkSubmitDebugUtilsMessageEXT           = 0;
+    PFN_vkTrimCommandPoolKHR                   vkTrimCommandPoolKHR                   = 0;
+    PFN_vkTrimCommandPool                      vkTrimCommandPool                      = 0;
+    PFN_vkUninitializePerformanceApiINTEL      vkUninitializePerformanceApiINTEL      = 0;
+    PFN_vkUnmapMemory                          vkUnmapMemory                          = 0;
+    PFN_vkUpdateDescriptorSetWithTemplateKHR   vkUpdateDescriptorSetWithTemplateKHR   = 0;
+    PFN_vkUpdateDescriptorSetWithTemplate      vkUpdateDescriptorSetWithTemplate      = 0;
+    PFN_vkUpdateDescriptorSets                 vkUpdateDescriptorSets                 = 0;
+    PFN_vkWaitForFences                        vkWaitForFences                        = 0;
+    PFN_vkWaitSemaphoresKHR                    vkWaitSemaphoresKHR                    = 0;
+    PFN_vkWaitSemaphores                       vkWaitSemaphores                       = 0;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   public:
     DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default;
@@ -106112,6 +106115,10 @@ namespace VULKAN_HPP_NAMESPACE
     void init( VULKAN_HPP_NAMESPACE::Instance instanceCpp ) VULKAN_HPP_NOEXCEPT
     {
       VkInstance instance = static_cast<VkInstance>( instanceCpp );
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+      vkAcquireXlibDisplayEXT =
+        PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) );
+#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
       vkCreateAndroidSurfaceKHR =
         PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) );
@@ -106120,10 +106127,13 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) );
       vkCreateDebugUtilsMessengerEXT =
         PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) );
+      vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) );
 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
       vkCreateDirectFBSurfaceEXT =
         PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) );
 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+      vkCreateDisplayModeKHR =
+        PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) );
       vkCreateDisplayPlaneSurfaceKHR =
         PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) );
       vkCreateHeadlessSurfaceEXT =
@@ -106173,28 +106183,21 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) );
       vkDestroyInstance   = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) );
       vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) );
-      vkEnumeratePhysicalDeviceGroups =
-        PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) );
-      vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR(
-        vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) );
-      vkEnumeratePhysicalDevices =
-        PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) );
-      vkSubmitDebugUtilsMessageEXT =
-        PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) );
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-      vkAcquireXlibDisplayEXT =
-        PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) );
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-      vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) );
-      vkCreateDisplayModeKHR =
-        PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) );
       vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties(
         vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) );
       vkEnumerateDeviceLayerProperties =
         PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) );
+      vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR(
+        vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) );
+      vkEnumeratePhysicalDeviceGroups =
+        PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) );
+      if ( !vkEnumeratePhysicalDeviceGroups )
+        vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR;
       vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR =
         PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
           vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) );
+      vkEnumeratePhysicalDevices =
+        PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) );
       vkGetDisplayModeProperties2KHR =
         PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) );
       vkGetDisplayModePropertiesKHR =
@@ -106205,6 +106208,7 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) );
       vkGetDisplayPlaneSupportedDisplaysKHR = PFN_vkGetDisplayPlaneSupportedDisplaysKHR(
         vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) );
+      vkGetInstanceProcAddr = PFN_vkGetInstanceProcAddr( vkGetInstanceProcAddr( instance, "vkGetInstanceProcAddr" ) );
       vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) );
       vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
@@ -106221,69 +106225,89 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) );
       vkGetPhysicalDeviceDisplayPropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPropertiesKHR(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) );
-      vkGetPhysicalDeviceExternalBufferProperties = PFN_vkGetPhysicalDeviceExternalBufferProperties(
-        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) );
       vkGetPhysicalDeviceExternalBufferPropertiesKHR = PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) );
-      vkGetPhysicalDeviceExternalFenceProperties = PFN_vkGetPhysicalDeviceExternalFenceProperties(
-        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) );
+      vkGetPhysicalDeviceExternalBufferProperties = PFN_vkGetPhysicalDeviceExternalBufferProperties(
+        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) );
+      if ( !vkGetPhysicalDeviceExternalBufferProperties )
+        vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR;
       vkGetPhysicalDeviceExternalFencePropertiesKHR = PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) );
+      vkGetPhysicalDeviceExternalFenceProperties = PFN_vkGetPhysicalDeviceExternalFenceProperties(
+        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) );
+      if ( !vkGetPhysicalDeviceExternalFenceProperties )
+        vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR;
       vkGetPhysicalDeviceExternalImageFormatPropertiesNV = PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) );
-      vkGetPhysicalDeviceExternalSemaphoreProperties = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties(
-        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) );
       vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) );
+      vkGetPhysicalDeviceExternalSemaphoreProperties = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties(
+        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) );
+      if ( !vkGetPhysicalDeviceExternalSemaphoreProperties )
+        vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
       vkGetPhysicalDeviceFeatures =
         PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) );
-      vkGetPhysicalDeviceFeatures2 =
-        PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) );
       vkGetPhysicalDeviceFeatures2KHR =
         PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) );
+      vkGetPhysicalDeviceFeatures2 =
+        PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) );
+      if ( !vkGetPhysicalDeviceFeatures2 )
+        vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR;
       vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) );
-      vkGetPhysicalDeviceFormatProperties2 = PFN_vkGetPhysicalDeviceFormatProperties2(
-        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) );
       vkGetPhysicalDeviceFormatProperties2KHR = PFN_vkGetPhysicalDeviceFormatProperties2KHR(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) );
+      vkGetPhysicalDeviceFormatProperties2 = PFN_vkGetPhysicalDeviceFormatProperties2(
+        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) );
+      if ( !vkGetPhysicalDeviceFormatProperties2 )
+        vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR;
       vkGetPhysicalDeviceImageFormatProperties = PFN_vkGetPhysicalDeviceImageFormatProperties(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) );
-      vkGetPhysicalDeviceImageFormatProperties2 = PFN_vkGetPhysicalDeviceImageFormatProperties2(
-        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) );
       vkGetPhysicalDeviceImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceImageFormatProperties2KHR(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) );
+      vkGetPhysicalDeviceImageFormatProperties2 = PFN_vkGetPhysicalDeviceImageFormatProperties2(
+        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) );
+      if ( !vkGetPhysicalDeviceImageFormatProperties2 )
+        vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR;
       vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) );
-      vkGetPhysicalDeviceMemoryProperties2 = PFN_vkGetPhysicalDeviceMemoryProperties2(
-        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) );
       vkGetPhysicalDeviceMemoryProperties2KHR = PFN_vkGetPhysicalDeviceMemoryProperties2KHR(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) );
+      vkGetPhysicalDeviceMemoryProperties2 = PFN_vkGetPhysicalDeviceMemoryProperties2(
+        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) );
+      if ( !vkGetPhysicalDeviceMemoryProperties2 )
+        vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR;
       vkGetPhysicalDeviceMultisamplePropertiesEXT = PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) );
       vkGetPhysicalDevicePresentRectanglesKHR = PFN_vkGetPhysicalDevicePresentRectanglesKHR(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) );
       vkGetPhysicalDeviceProperties =
         PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) );
-      vkGetPhysicalDeviceProperties2 =
-        PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) );
       vkGetPhysicalDeviceProperties2KHR =
         PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) );
+      vkGetPhysicalDeviceProperties2 =
+        PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) );
+      if ( !vkGetPhysicalDeviceProperties2 )
+        vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR;
       vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR =
         PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
           vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) );
       vkGetPhysicalDeviceQueueFamilyProperties = PFN_vkGetPhysicalDeviceQueueFamilyProperties(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) );
-      vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2(
-        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) );
       vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) );
+      vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2(
+        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) );
+      if ( !vkGetPhysicalDeviceQueueFamilyProperties2 )
+        vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR;
       vkGetPhysicalDeviceSparseImageFormatProperties = PFN_vkGetPhysicalDeviceSparseImageFormatProperties(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) );
-      vkGetPhysicalDeviceSparseImageFormatProperties2 = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(
-        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) );
       vkGetPhysicalDeviceSparseImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) );
+      vkGetPhysicalDeviceSparseImageFormatProperties2 = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(
+        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) );
+      if ( !vkGetPhysicalDeviceSparseImageFormatProperties2 )
+        vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
       vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV =
         PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
           vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) );
@@ -106327,8 +106351,49 @@ namespace VULKAN_HPP_NAMESPACE
       vkGetRandROutputDisplayEXT =
         PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) );
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-      vkReleaseDisplayEXT  = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) );
+      vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) );
+      vkSubmitDebugUtilsMessageEXT =
+        PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+      vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT(
+        vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+      vkAcquireNextImage2KHR =
+        PFN_vkAcquireNextImage2KHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) );
+      vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) );
+      vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL(
+        vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) );
+      vkAcquireProfilingLockKHR =
+        PFN_vkAcquireProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkAcquireProfilingLockKHR" ) );
+      vkAllocateCommandBuffers =
+        PFN_vkAllocateCommandBuffers( vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) );
+      vkAllocateDescriptorSets =
+        PFN_vkAllocateDescriptorSets( vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) );
+      vkAllocateMemory     = PFN_vkAllocateMemory( vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) );
       vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetInstanceProcAddr( instance, "vkBeginCommandBuffer" ) );
+      vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV(
+        vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryNV" ) );
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+      vkBindAccelerationStructureMemoryKHR = PFN_vkBindAccelerationStructureMemoryKHR(
+        vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryKHR" ) );
+      if ( !vkBindAccelerationStructureMemoryKHR )
+        vkBindAccelerationStructureMemoryKHR = vkBindAccelerationStructureMemoryNV;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetInstanceProcAddr( instance, "vkBindBufferMemory" ) );
+      vkBindBufferMemory2KHR =
+        PFN_vkBindBufferMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2KHR" ) );
+      vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2" ) );
+      if ( !vkBindBufferMemory2 )
+        vkBindBufferMemory2 = vkBindBufferMemory2KHR;
+      vkBindImageMemory     = PFN_vkBindImageMemory( vkGetInstanceProcAddr( instance, "vkBindImageMemory" ) );
+      vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindImageMemory2KHR" ) );
+      vkBindImageMemory2    = PFN_vkBindImageMemory2( vkGetInstanceProcAddr( instance, "vkBindImageMemory2" ) );
+      if ( !vkBindImageMemory2 )
+        vkBindImageMemory2 = vkBindImageMemory2KHR;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+      vkBuildAccelerationStructureKHR =
+        PFN_vkBuildAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkBuildAccelerationStructureKHR" ) );
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
       vkCmdBeginConditionalRenderingEXT =
         PFN_vkCmdBeginConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginConditionalRenderingEXT" ) );
       vkCmdBeginDebugUtilsLabelEXT =
@@ -106336,10 +106401,12 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetInstanceProcAddr( instance, "vkCmdBeginQuery" ) );
       vkCmdBeginQueryIndexedEXT =
         PFN_vkCmdBeginQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginQueryIndexedEXT" ) );
-      vkCmdBeginRenderPass  = PFN_vkCmdBeginRenderPass( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass" ) );
-      vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2" ) );
+      vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass" ) );
       vkCmdBeginRenderPass2KHR =
         PFN_vkCmdBeginRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2KHR" ) );
+      vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2" ) );
+      if ( !vkCmdBeginRenderPass2 )
+        vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR;
       vkCmdBeginTransformFeedbackEXT =
         PFN_vkCmdBeginTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginTransformFeedbackEXT" ) );
       vkCmdBindDescriptorSets =
@@ -106399,29 +106466,39 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkCmdDebugMarkerEndEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerEndEXT" ) );
       vkCmdDebugMarkerInsertEXT =
         PFN_vkCmdDebugMarkerInsertEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerInsertEXT" ) );
-      vkCmdDispatch         = PFN_vkCmdDispatch( vkGetInstanceProcAddr( instance, "vkCmdDispatch" ) );
-      vkCmdDispatchBase     = PFN_vkCmdDispatchBase( vkGetInstanceProcAddr( instance, "vkCmdDispatchBase" ) );
-      vkCmdDispatchBaseKHR  = PFN_vkCmdDispatchBaseKHR( vkGetInstanceProcAddr( instance, "vkCmdDispatchBaseKHR" ) );
+      vkCmdDispatch        = PFN_vkCmdDispatch( vkGetInstanceProcAddr( instance, "vkCmdDispatch" ) );
+      vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetInstanceProcAddr( instance, "vkCmdDispatchBaseKHR" ) );
+      vkCmdDispatchBase    = PFN_vkCmdDispatchBase( vkGetInstanceProcAddr( instance, "vkCmdDispatchBase" ) );
+      if ( !vkCmdDispatchBase )
+        vkCmdDispatchBase = vkCmdDispatchBaseKHR;
       vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetInstanceProcAddr( instance, "vkCmdDispatchIndirect" ) );
       vkCmdDraw             = PFN_vkCmdDraw( vkGetInstanceProcAddr( instance, "vkCmdDraw" ) );
       vkCmdDrawIndexed      = PFN_vkCmdDrawIndexed( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexed" ) );
       vkCmdDrawIndexedIndirect =
         PFN_vkCmdDrawIndexedIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirect" ) );
-      vkCmdDrawIndexedIndirectCount =
-        PFN_vkCmdDrawIndexedIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCount" ) );
       vkCmdDrawIndexedIndirectCountAMD =
         PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountAMD" ) );
       vkCmdDrawIndexedIndirectCountKHR =
         PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountKHR" ) );
+      vkCmdDrawIndexedIndirectCount =
+        PFN_vkCmdDrawIndexedIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCount" ) );
+      if ( !vkCmdDrawIndexedIndirectCount )
+        vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;
+      if ( !vkCmdDrawIndexedIndirectCount )
+        vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD;
       vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirect" ) );
       vkCmdDrawIndirectByteCountEXT =
         PFN_vkCmdDrawIndirectByteCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectByteCountEXT" ) );
-      vkCmdDrawIndirectCount =
-        PFN_vkCmdDrawIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCount" ) );
       vkCmdDrawIndirectCountAMD =
         PFN_vkCmdDrawIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountAMD" ) );
       vkCmdDrawIndirectCountKHR =
         PFN_vkCmdDrawIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountKHR" ) );
+      vkCmdDrawIndirectCount =
+        PFN_vkCmdDrawIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCount" ) );
+      if ( !vkCmdDrawIndirectCount )
+        vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
+      if ( !vkCmdDrawIndirectCount )
+        vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD;
       vkCmdDrawMeshTasksIndirectCountNV =
         PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountNV" ) );
       vkCmdDrawMeshTasksIndirectNV =
@@ -106434,10 +106511,12 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetInstanceProcAddr( instance, "vkCmdEndQuery" ) );
       vkCmdEndQueryIndexedEXT =
         PFN_vkCmdEndQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdEndQueryIndexedEXT" ) );
-      vkCmdEndRenderPass  = PFN_vkCmdEndRenderPass( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass" ) );
-      vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2" ) );
+      vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass" ) );
       vkCmdEndRenderPass2KHR =
         PFN_vkCmdEndRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2KHR" ) );
+      vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2" ) );
+      if ( !vkCmdEndRenderPass2 )
+        vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR;
       vkCmdEndTransformFeedbackEXT =
         PFN_vkCmdEndTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdEndTransformFeedbackEXT" ) );
       vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetInstanceProcAddr( instance, "vkCmdExecuteCommands" ) );
@@ -106447,8 +106526,10 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdInsertDebugUtilsLabelEXT =
         PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdInsertDebugUtilsLabelEXT" ) );
       vkCmdNextSubpass     = PFN_vkCmdNextSubpass( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass" ) );
-      vkCmdNextSubpass2    = PFN_vkCmdNextSubpass2( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2" ) );
       vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2KHR" ) );
+      vkCmdNextSubpass2    = PFN_vkCmdNextSubpass2( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2" ) );
+      if ( !vkCmdNextSubpass2 )
+        vkCmdNextSubpass2 = vkCmdNextSubpass2KHR;
       vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier" ) );
       vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV(
         vkGetInstanceProcAddr( instance, "vkCmdPreprocessGeneratedCommandsNV" ) );
@@ -106476,8 +106557,10 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkCmdSetDepthTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnableEXT" ) );
       vkCmdSetDepthWriteEnableEXT =
         PFN_vkCmdSetDepthWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnableEXT" ) );
-      vkCmdSetDeviceMask    = PFN_vkCmdSetDeviceMask( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) );
       vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMaskKHR" ) );
+      vkCmdSetDeviceMask    = PFN_vkCmdSetDeviceMask( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) );
+      if ( !vkCmdSetDeviceMask )
+        vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR;
       vkCmdSetDiscardRectangleEXT =
         PFN_vkCmdSetDiscardRectangleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) );
       vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) );
@@ -106526,50 +106609,17 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdTraceRaysNV  = PFN_vkCmdTraceRaysNV( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysNV" ) );
       vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetInstanceProcAddr( instance, "vkCmdUpdateBuffer" ) );
       vkCmdWaitEvents   = PFN_vkCmdWaitEvents( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents" ) );
+      vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV(
+        vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkCmdWriteAccelerationStructuresPropertiesKHR = PFN_vkCmdWriteAccelerationStructuresPropertiesKHR(
         vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) );
+      if ( !vkCmdWriteAccelerationStructuresPropertiesKHR )
+        vkCmdWriteAccelerationStructuresPropertiesKHR = vkCmdWriteAccelerationStructuresPropertiesNV;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV(
-        vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
       vkCmdWriteBufferMarkerAMD =
         PFN_vkCmdWriteBufferMarkerAMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarkerAMD" ) );
-      vkCmdWriteTimestamp  = PFN_vkCmdWriteTimestamp( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) );
-      vkEndCommandBuffer   = PFN_vkEndCommandBuffer( vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) );
-      vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-      vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT(
-        vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-      vkAcquireNextImage2KHR =
-        PFN_vkAcquireNextImage2KHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) );
-      vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) );
-      vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL(
-        vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) );
-      vkAcquireProfilingLockKHR =
-        PFN_vkAcquireProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkAcquireProfilingLockKHR" ) );
-      vkAllocateCommandBuffers =
-        PFN_vkAllocateCommandBuffers( vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) );
-      vkAllocateDescriptorSets =
-        PFN_vkAllocateDescriptorSets( vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) );
-      vkAllocateMemory = PFN_vkAllocateMemory( vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) );
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-      vkBindAccelerationStructureMemoryKHR = PFN_vkBindAccelerationStructureMemoryKHR(
-        vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryKHR" ) );
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV(
-        vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryNV" ) );
-      vkBindBufferMemory  = PFN_vkBindBufferMemory( vkGetInstanceProcAddr( instance, "vkBindBufferMemory" ) );
-      vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2" ) );
-      vkBindBufferMemory2KHR =
-        PFN_vkBindBufferMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2KHR" ) );
-      vkBindImageMemory     = PFN_vkBindImageMemory( vkGetInstanceProcAddr( instance, "vkBindImageMemory" ) );
-      vkBindImageMemory2    = PFN_vkBindImageMemory2( vkGetInstanceProcAddr( instance, "vkBindImageMemory2" ) );
-      vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindImageMemory2KHR" ) );
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-      vkBuildAccelerationStructureKHR =
-        PFN_vkBuildAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkBuildAccelerationStructureKHR" ) );
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) );
       vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetInstanceProcAddr( instance, "vkCompileDeferredNV" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkCopyAccelerationStructureKHR =
@@ -106602,10 +106652,12 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkCreateDescriptorPool( vkGetInstanceProcAddr( instance, "vkCreateDescriptorPool" ) );
       vkCreateDescriptorSetLayout =
         PFN_vkCreateDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkCreateDescriptorSetLayout" ) );
-      vkCreateDescriptorUpdateTemplate =
-        PFN_vkCreateDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplate" ) );
       vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR(
         vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplateKHR" ) );
+      vkCreateDescriptorUpdateTemplate =
+        PFN_vkCreateDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplate" ) );
+      if ( !vkCreateDescriptorUpdateTemplate )
+        vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR;
       vkCreateEvent       = PFN_vkCreateEvent( vkGetInstanceProcAddr( instance, "vkCreateEvent" ) );
       vkCreateFence       = PFN_vkCreateFence( vkGetInstanceProcAddr( instance, "vkCreateFence" ) );
       vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetInstanceProcAddr( instance, "vkCreateFramebuffer" ) );
@@ -106627,15 +106679,19 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
       vkCreateRayTracingPipelinesNV =
         PFN_vkCreateRayTracingPipelinesNV( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesNV" ) );
-      vkCreateRenderPass  = PFN_vkCreateRenderPass( vkGetInstanceProcAddr( instance, "vkCreateRenderPass" ) );
-      vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2" ) );
+      vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetInstanceProcAddr( instance, "vkCreateRenderPass" ) );
       vkCreateRenderPass2KHR =
         PFN_vkCreateRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2KHR" ) );
+      vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2" ) );
+      if ( !vkCreateRenderPass2 )
+        vkCreateRenderPass2 = vkCreateRenderPass2KHR;
       vkCreateSampler = PFN_vkCreateSampler( vkGetInstanceProcAddr( instance, "vkCreateSampler" ) );
-      vkCreateSamplerYcbcrConversion =
-        PFN_vkCreateSamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversion" ) );
       vkCreateSamplerYcbcrConversionKHR =
         PFN_vkCreateSamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversionKHR" ) );
+      vkCreateSamplerYcbcrConversion =
+        PFN_vkCreateSamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversion" ) );
+      if ( !vkCreateSamplerYcbcrConversion )
+        vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR;
       vkCreateSemaphore    = PFN_vkCreateSemaphore( vkGetInstanceProcAddr( instance, "vkCreateSemaphore" ) );
       vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetInstanceProcAddr( instance, "vkCreateShaderModule" ) );
       vkCreateSharedSwapchainsKHR =
@@ -106651,12 +106707,14 @@ namespace VULKAN_HPP_NAMESPACE
       vkDeferredOperationJoinKHR =
         PFN_vkDeferredOperationJoinKHR( vkGetInstanceProcAddr( instance, "vkDeferredOperationJoinKHR" ) );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      vkDestroyAccelerationStructureNV =
+        PFN_vkDestroyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureNV" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkDestroyAccelerationStructureKHR =
         PFN_vkDestroyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureKHR" ) );
+      if ( !vkDestroyAccelerationStructureKHR )
+        vkDestroyAccelerationStructureKHR = vkDestroyAccelerationStructureNV;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkDestroyAccelerationStructureNV =
-        PFN_vkDestroyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureNV" ) );
       vkDestroyBuffer      = PFN_vkDestroyBuffer( vkGetInstanceProcAddr( instance, "vkDestroyBuffer" ) );
       vkDestroyBufferView  = PFN_vkDestroyBufferView( vkGetInstanceProcAddr( instance, "vkDestroyBufferView" ) );
       vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetInstanceProcAddr( instance, "vkDestroyCommandPool" ) );
@@ -106668,10 +106726,12 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkDestroyDescriptorPool( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorPool" ) );
       vkDestroyDescriptorSetLayout =
         PFN_vkDestroyDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorSetLayout" ) );
-      vkDestroyDescriptorUpdateTemplate =
-        PFN_vkDestroyDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplate" ) );
       vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR(
         vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplateKHR" ) );
+      vkDestroyDescriptorUpdateTemplate =
+        PFN_vkDestroyDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplate" ) );
+      if ( !vkDestroyDescriptorUpdateTemplate )
+        vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR;
       vkDestroyDevice      = PFN_vkDestroyDevice( vkGetInstanceProcAddr( instance, "vkDestroyDevice" ) );
       vkDestroyEvent       = PFN_vkDestroyEvent( vkGetInstanceProcAddr( instance, "vkDestroyEvent" ) );
       vkDestroyFence       = PFN_vkDestroyFence( vkGetInstanceProcAddr( instance, "vkDestroyFence" ) );
@@ -106690,10 +106750,12 @@ namespace VULKAN_HPP_NAMESPACE
       vkDestroyQueryPool  = PFN_vkDestroyQueryPool( vkGetInstanceProcAddr( instance, "vkDestroyQueryPool" ) );
       vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetInstanceProcAddr( instance, "vkDestroyRenderPass" ) );
       vkDestroySampler    = PFN_vkDestroySampler( vkGetInstanceProcAddr( instance, "vkDestroySampler" ) );
-      vkDestroySamplerYcbcrConversion =
-        PFN_vkDestroySamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversion" ) );
       vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(
         vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversionKHR" ) );
+      vkDestroySamplerYcbcrConversion =
+        PFN_vkDestroySamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversion" ) );
+      if ( !vkDestroySamplerYcbcrConversion )
+        vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR;
       vkDestroySemaphore    = PFN_vkDestroySemaphore( vkGetInstanceProcAddr( instance, "vkDestroySemaphore" ) );
       vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetInstanceProcAddr( instance, "vkDestroyShaderModule" ) );
       vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetInstanceProcAddr( instance, "vkDestroySwapchainKHR" ) );
@@ -106702,6 +106764,7 @@ namespace VULKAN_HPP_NAMESPACE
       vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetInstanceProcAddr( instance, "vkDeviceWaitIdle" ) );
       vkDisplayPowerControlEXT =
         PFN_vkDisplayPowerControlEXT( vkGetInstanceProcAddr( instance, "vkDisplayPowerControlEXT" ) );
+      vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) );
       vkFlushMappedMemoryRanges =
         PFN_vkFlushMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkFlushMappedMemoryRanges" ) );
       vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetInstanceProcAddr( instance, "vkFreeCommandBuffers" ) );
@@ -106723,22 +106786,30 @@ namespace VULKAN_HPP_NAMESPACE
       vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID(
         vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-      vkGetBufferDeviceAddress =
-        PFN_vkGetBufferDeviceAddress( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddress" ) );
       vkGetBufferDeviceAddressEXT =
         PFN_vkGetBufferDeviceAddressEXT( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressEXT" ) );
       vkGetBufferDeviceAddressKHR =
         PFN_vkGetBufferDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressKHR" ) );
+      vkGetBufferDeviceAddress =
+        PFN_vkGetBufferDeviceAddress( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddress" ) );
+      if ( !vkGetBufferDeviceAddress )
+        vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
+      if ( !vkGetBufferDeviceAddress )
+        vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT;
       vkGetBufferMemoryRequirements =
         PFN_vkGetBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements" ) );
-      vkGetBufferMemoryRequirements2 =
-        PFN_vkGetBufferMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2" ) );
       vkGetBufferMemoryRequirements2KHR =
         PFN_vkGetBufferMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2KHR" ) );
-      vkGetBufferOpaqueCaptureAddress =
-        PFN_vkGetBufferOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddress" ) );
+      vkGetBufferMemoryRequirements2 =
+        PFN_vkGetBufferMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2" ) );
+      if ( !vkGetBufferMemoryRequirements2 )
+        vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR;
       vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR(
         vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddressKHR" ) );
+      vkGetBufferOpaqueCaptureAddress =
+        PFN_vkGetBufferOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddress" ) );
+      if ( !vkGetBufferOpaqueCaptureAddress )
+        vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR;
       vkGetCalibratedTimestampsEXT =
         PFN_vkGetCalibratedTimestampsEXT( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsEXT" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
@@ -106749,18 +106820,22 @@ namespace VULKAN_HPP_NAMESPACE
       vkGetDeferredOperationResultKHR =
         PFN_vkGetDeferredOperationResultKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationResultKHR" ) );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkGetDescriptorSetLayoutSupport =
-        PFN_vkGetDescriptorSetLayoutSupport( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupport" ) );
       vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(
         vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupportKHR" ) );
+      vkGetDescriptorSetLayoutSupport =
+        PFN_vkGetDescriptorSetLayoutSupport( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupport" ) );
+      if ( !vkGetDescriptorSetLayoutSupport )
+        vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkGetDeviceAccelerationStructureCompatibilityKHR = PFN_vkGetDeviceAccelerationStructureCompatibilityKHR(
         vkGetInstanceProcAddr( instance, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(
-        vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) );
       vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR(
         vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
+      vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(
+        vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) );
+      if ( !vkGetDeviceGroupPeerMemoryFeatures )
+        vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR;
       vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR(
         vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
 #ifdef VK_USE_PLATFORM_WIN32_KHR
@@ -106771,10 +106846,12 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
       vkGetDeviceMemoryCommitment =
         PFN_vkGetDeviceMemoryCommitment( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) );
-      vkGetDeviceMemoryOpaqueCaptureAddress = PFN_vkGetDeviceMemoryOpaqueCaptureAddress(
-        vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
       vkGetDeviceMemoryOpaqueCaptureAddressKHR = PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR(
         vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) );
+      vkGetDeviceMemoryOpaqueCaptureAddress = PFN_vkGetDeviceMemoryOpaqueCaptureAddress(
+        vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
+      if ( !vkGetDeviceMemoryOpaqueCaptureAddress )
+        vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR;
       vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) );
       vkGetDeviceQueue    = PFN_vkGetDeviceQueue( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) );
       vkGetDeviceQueue2   = PFN_vkGetDeviceQueue2( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue2" ) );
@@ -106791,16 +106868,20 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetInstanceProcAddr( instance, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
       vkGetImageMemoryRequirements =
         PFN_vkGetImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements" ) );
-      vkGetImageMemoryRequirements2 =
-        PFN_vkGetImageMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2" ) );
       vkGetImageMemoryRequirements2KHR =
         PFN_vkGetImageMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2KHR" ) );
+      vkGetImageMemoryRequirements2 =
+        PFN_vkGetImageMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2" ) );
+      if ( !vkGetImageMemoryRequirements2 )
+        vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR;
       vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements(
         vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements" ) );
-      vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2(
-        vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2" ) );
       vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR(
         vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2KHR" ) );
+      vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2(
+        vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2" ) );
+      if ( !vkGetImageSparseMemoryRequirements2 )
+        vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR;
       vkGetImageSubresourceLayout =
         PFN_vkGetImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout" ) );
       vkGetImageViewAddressNVX =
@@ -106842,24 +106923,30 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableStatisticsKHR" ) );
       vkGetPrivateDataEXT   = PFN_vkGetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkGetPrivateDataEXT" ) );
       vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) );
+      vkGetQueueCheckpointDataNV =
+        PFN_vkGetQueueCheckpointDataNV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointDataNV" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
         vkGetInstanceProcAddr( instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV(
+        vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkGetRayTracingShaderGroupHandlesKHR = PFN_vkGetRayTracingShaderGroupHandlesKHR(
         vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesKHR" ) );
+      if ( !vkGetRayTracingShaderGroupHandlesKHR )
+        vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV(
-        vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) );
       vkGetRefreshCycleDurationGOOGLE =
         PFN_vkGetRefreshCycleDurationGOOGLE( vkGetInstanceProcAddr( instance, "vkGetRefreshCycleDurationGOOGLE" ) );
       vkGetRenderAreaGranularity =
         PFN_vkGetRenderAreaGranularity( vkGetInstanceProcAddr( instance, "vkGetRenderAreaGranularity" ) );
-      vkGetSemaphoreCounterValue =
-        PFN_vkGetSemaphoreCounterValue( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValue" ) );
       vkGetSemaphoreCounterValueKHR =
         PFN_vkGetSemaphoreCounterValueKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValueKHR" ) );
+      vkGetSemaphoreCounterValue =
+        PFN_vkGetSemaphoreCounterValue( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValue" ) );
+      if ( !vkGetSemaphoreCounterValue )
+        vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR;
       vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreFdKHR" ) );
 #ifdef VK_USE_PLATFORM_WIN32_KHR
       vkGetSemaphoreWin32HandleKHR =
@@ -106893,54 +106980,6 @@ namespace VULKAN_HPP_NAMESPACE
       vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetInstanceProcAddr( instance, "vkMergePipelineCaches" ) );
       vkMergeValidationCachesEXT =
         PFN_vkMergeValidationCachesEXT( vkGetInstanceProcAddr( instance, "vkMergeValidationCachesEXT" ) );
-      vkRegisterDeviceEventEXT =
-        PFN_vkRegisterDeviceEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) );
-      vkRegisterDisplayEventEXT =
-        PFN_vkRegisterDisplayEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-      vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT(
-        vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-      vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL(
-        vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) );
-      vkReleaseProfilingLockKHR =
-        PFN_vkReleaseProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkReleaseProfilingLockKHR" ) );
-      vkResetCommandPool    = PFN_vkResetCommandPool( vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) );
-      vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) );
-      vkResetEvent          = PFN_vkResetEvent( vkGetInstanceProcAddr( instance, "vkResetEvent" ) );
-      vkResetFences         = PFN_vkResetFences( vkGetInstanceProcAddr( instance, "vkResetFences" ) );
-      vkResetQueryPool      = PFN_vkResetQueryPool( vkGetInstanceProcAddr( instance, "vkResetQueryPool" ) );
-      vkResetQueryPoolEXT   = PFN_vkResetQueryPoolEXT( vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) );
-      vkSetDebugUtilsObjectNameEXT =
-        PFN_vkSetDebugUtilsObjectNameEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) );
-      vkSetDebugUtilsObjectTagEXT =
-        PFN_vkSetDebugUtilsObjectTagEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) );
-      vkSetEvent           = PFN_vkSetEvent( vkGetInstanceProcAddr( instance, "vkSetEvent" ) );
-      vkSetHdrMetadataEXT  = PFN_vkSetHdrMetadataEXT( vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) );
-      vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetInstanceProcAddr( instance, "vkSetLocalDimmingAMD" ) );
-      vkSetPrivateDataEXT  = PFN_vkSetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkSetPrivateDataEXT" ) );
-      vkSignalSemaphore    = PFN_vkSignalSemaphore( vkGetInstanceProcAddr( instance, "vkSignalSemaphore" ) );
-      vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetInstanceProcAddr( instance, "vkSignalSemaphoreKHR" ) );
-      vkTrimCommandPool    = PFN_vkTrimCommandPool( vkGetInstanceProcAddr( instance, "vkTrimCommandPool" ) );
-      vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetInstanceProcAddr( instance, "vkTrimCommandPoolKHR" ) );
-      vkUninitializePerformanceApiINTEL =
-        PFN_vkUninitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkUninitializePerformanceApiINTEL" ) );
-      vkUnmapMemory = PFN_vkUnmapMemory( vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) );
-      vkUpdateDescriptorSetWithTemplate =
-        PFN_vkUpdateDescriptorSetWithTemplate( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplate" ) );
-      vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR(
-        vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplateKHR" ) );
-      vkUpdateDescriptorSets =
-        PFN_vkUpdateDescriptorSets( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSets" ) );
-      vkWaitForFences     = PFN_vkWaitForFences( vkGetInstanceProcAddr( instance, "vkWaitForFences" ) );
-      vkWaitSemaphores    = PFN_vkWaitSemaphores( vkGetInstanceProcAddr( instance, "vkWaitSemaphores" ) );
-      vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetInstanceProcAddr( instance, "vkWaitSemaphoresKHR" ) );
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-      vkWriteAccelerationStructuresPropertiesKHR = PFN_vkWriteAccelerationStructuresPropertiesKHR(
-        vkGetInstanceProcAddr( instance, "vkWriteAccelerationStructuresPropertiesKHR" ) );
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkGetQueueCheckpointDataNV =
-        PFN_vkGetQueueCheckpointDataNV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointDataNV" ) );
       vkQueueBeginDebugUtilsLabelEXT =
         PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueBeginDebugUtilsLabelEXT" ) );
       vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetInstanceProcAddr( instance, "vkQueueBindSparse" ) );
@@ -106953,12 +106992,106 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetInstanceProcAddr( instance, "vkQueueSetPerformanceConfigurationINTEL" ) );
       vkQueueSubmit   = PFN_vkQueueSubmit( vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) );
       vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) );
+      vkRegisterDeviceEventEXT =
+        PFN_vkRegisterDeviceEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) );
+      vkRegisterDisplayEventEXT =
+        PFN_vkRegisterDisplayEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+      vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT(
+        vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+      vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL(
+        vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) );
+      vkReleaseProfilingLockKHR =
+        PFN_vkReleaseProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkReleaseProfilingLockKHR" ) );
+      vkResetCommandBuffer  = PFN_vkResetCommandBuffer( vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) );
+      vkResetCommandPool    = PFN_vkResetCommandPool( vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) );
+      vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) );
+      vkResetEvent          = PFN_vkResetEvent( vkGetInstanceProcAddr( instance, "vkResetEvent" ) );
+      vkResetFences         = PFN_vkResetFences( vkGetInstanceProcAddr( instance, "vkResetFences" ) );
+      vkResetQueryPoolEXT   = PFN_vkResetQueryPoolEXT( vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) );
+      vkResetQueryPool      = PFN_vkResetQueryPool( vkGetInstanceProcAddr( instance, "vkResetQueryPool" ) );
+      if ( !vkResetQueryPool )
+        vkResetQueryPool = vkResetQueryPoolEXT;
+      vkSetDebugUtilsObjectNameEXT =
+        PFN_vkSetDebugUtilsObjectNameEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) );
+      vkSetDebugUtilsObjectTagEXT =
+        PFN_vkSetDebugUtilsObjectTagEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) );
+      vkSetEvent           = PFN_vkSetEvent( vkGetInstanceProcAddr( instance, "vkSetEvent" ) );
+      vkSetHdrMetadataEXT  = PFN_vkSetHdrMetadataEXT( vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) );
+      vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetInstanceProcAddr( instance, "vkSetLocalDimmingAMD" ) );
+      vkSetPrivateDataEXT  = PFN_vkSetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkSetPrivateDataEXT" ) );
+      vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetInstanceProcAddr( instance, "vkSignalSemaphoreKHR" ) );
+      vkSignalSemaphore    = PFN_vkSignalSemaphore( vkGetInstanceProcAddr( instance, "vkSignalSemaphore" ) );
+      if ( !vkSignalSemaphore )
+        vkSignalSemaphore = vkSignalSemaphoreKHR;
+      vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetInstanceProcAddr( instance, "vkTrimCommandPoolKHR" ) );
+      vkTrimCommandPool    = PFN_vkTrimCommandPool( vkGetInstanceProcAddr( instance, "vkTrimCommandPool" ) );
+      if ( !vkTrimCommandPool )
+        vkTrimCommandPool = vkTrimCommandPoolKHR;
+      vkUninitializePerformanceApiINTEL =
+        PFN_vkUninitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkUninitializePerformanceApiINTEL" ) );
+      vkUnmapMemory                        = PFN_vkUnmapMemory( vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) );
+      vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR(
+        vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplateKHR" ) );
+      vkUpdateDescriptorSetWithTemplate =
+        PFN_vkUpdateDescriptorSetWithTemplate( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplate" ) );
+      if ( !vkUpdateDescriptorSetWithTemplate )
+        vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR;
+      vkUpdateDescriptorSets =
+        PFN_vkUpdateDescriptorSets( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSets" ) );
+      vkWaitForFences     = PFN_vkWaitForFences( vkGetInstanceProcAddr( instance, "vkWaitForFences" ) );
+      vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetInstanceProcAddr( instance, "vkWaitSemaphoresKHR" ) );
+      vkWaitSemaphores    = PFN_vkWaitSemaphores( vkGetInstanceProcAddr( instance, "vkWaitSemaphores" ) );
+      if ( !vkWaitSemaphores )
+        vkWaitSemaphores = vkWaitSemaphoresKHR;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+      vkWriteAccelerationStructuresPropertiesKHR = PFN_vkWriteAccelerationStructuresPropertiesKHR(
+        vkGetInstanceProcAddr( instance, "vkWriteAccelerationStructuresPropertiesKHR" ) );
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
     }
 
     void init( VULKAN_HPP_NAMESPACE::Device deviceCpp ) VULKAN_HPP_NOEXCEPT
     {
-      VkDevice device      = static_cast<VkDevice>( deviceCpp );
+      VkDevice device = static_cast<VkDevice>( deviceCpp );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+      vkAcquireFullScreenExclusiveModeEXT =
+        PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+      vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) );
+      vkAcquireNextImageKHR  = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) );
+      vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL(
+        vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) );
+      vkAcquireProfilingLockKHR =
+        PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) );
+      vkAllocateCommandBuffers =
+        PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) );
+      vkAllocateDescriptorSets =
+        PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) );
+      vkAllocateMemory     = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) );
       vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) );
+      vkBindAccelerationStructureMemoryNV =
+        PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) );
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+      vkBindAccelerationStructureMemoryKHR = PFN_vkBindAccelerationStructureMemoryKHR(
+        vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryKHR" ) );
+      if ( !vkBindAccelerationStructureMemoryKHR )
+        vkBindAccelerationStructureMemoryKHR = vkBindAccelerationStructureMemoryNV;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      vkBindBufferMemory     = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) );
+      vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) );
+      vkBindBufferMemory2    = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) );
+      if ( !vkBindBufferMemory2 )
+        vkBindBufferMemory2 = vkBindBufferMemory2KHR;
+      vkBindImageMemory     = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) );
+      vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) );
+      vkBindImageMemory2    = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) );
+      if ( !vkBindImageMemory2 )
+        vkBindImageMemory2 = vkBindImageMemory2KHR;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+      vkBuildAccelerationStructureKHR =
+        PFN_vkBuildAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructureKHR" ) );
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
       vkCmdBeginConditionalRenderingEXT =
         PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) );
       vkCmdBeginDebugUtilsLabelEXT =
@@ -106966,10 +107099,12 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) );
       vkCmdBeginQueryIndexedEXT =
         PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) );
-      vkCmdBeginRenderPass  = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) );
-      vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) );
+      vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) );
       vkCmdBeginRenderPass2KHR =
         PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) );
+      vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) );
+      if ( !vkCmdBeginRenderPass2 )
+        vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR;
       vkCmdBeginTransformFeedbackEXT =
         PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) );
       vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) );
@@ -107024,28 +107159,38 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) );
       vkCmdDebugMarkerInsertEXT =
         PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) );
-      vkCmdDispatch         = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) );
-      vkCmdDispatchBase     = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) );
-      vkCmdDispatchBaseKHR  = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) );
+      vkCmdDispatch        = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) );
+      vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) );
+      vkCmdDispatchBase    = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) );
+      if ( !vkCmdDispatchBase )
+        vkCmdDispatchBase = vkCmdDispatchBaseKHR;
       vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) );
       vkCmdDraw             = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) );
       vkCmdDrawIndexed      = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) );
       vkCmdDrawIndexedIndirect =
         PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) );
-      vkCmdDrawIndexedIndirectCount =
-        PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) );
       vkCmdDrawIndexedIndirectCountAMD =
         PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) );
       vkCmdDrawIndexedIndirectCountKHR =
         PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) );
+      vkCmdDrawIndexedIndirectCount =
+        PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) );
+      if ( !vkCmdDrawIndexedIndirectCount )
+        vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;
+      if ( !vkCmdDrawIndexedIndirectCount )
+        vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD;
       vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) );
       vkCmdDrawIndirectByteCountEXT =
         PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) );
-      vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) );
       vkCmdDrawIndirectCountAMD =
         PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) );
       vkCmdDrawIndirectCountKHR =
         PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) );
+      vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) );
+      if ( !vkCmdDrawIndirectCount )
+        vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
+      if ( !vkCmdDrawIndirectCount )
+        vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD;
       vkCmdDrawMeshTasksIndirectCountNV =
         PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) );
       vkCmdDrawMeshTasksIndirectNV =
@@ -107058,8 +107203,10 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdEndQuery           = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) );
       vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) );
       vkCmdEndRenderPass      = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) );
-      vkCmdEndRenderPass2     = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) );
       vkCmdEndRenderPass2KHR  = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) );
+      vkCmdEndRenderPass2     = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) );
+      if ( !vkCmdEndRenderPass2 )
+        vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR;
       vkCmdEndTransformFeedbackEXT =
         PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) );
       vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) );
@@ -107069,8 +107216,10 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdInsertDebugUtilsLabelEXT =
         PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) );
       vkCmdNextSubpass     = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) );
-      vkCmdNextSubpass2    = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) );
       vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) );
+      vkCmdNextSubpass2    = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) );
+      if ( !vkCmdNextSubpass2 )
+        vkCmdNextSubpass2 = vkCmdNextSubpass2KHR;
       vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) );
       vkCmdPreprocessGeneratedCommandsNV =
         PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) );
@@ -107097,8 +107246,10 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) );
       vkCmdSetDepthWriteEnableEXT =
         PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) );
-      vkCmdSetDeviceMask    = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) );
       vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) );
+      vkCmdSetDeviceMask    = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) );
+      if ( !vkCmdSetDeviceMask )
+        vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR;
       vkCmdSetDiscardRectangleEXT =
         PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) );
       vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) );
@@ -107146,48 +107297,17 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdTraceRaysNV  = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) );
       vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) );
       vkCmdWaitEvents   = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) );
+      vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV(
+        vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkCmdWriteAccelerationStructuresPropertiesKHR = PFN_vkCmdWriteAccelerationStructuresPropertiesKHR(
         vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) );
+      if ( !vkCmdWriteAccelerationStructuresPropertiesKHR )
+        vkCmdWriteAccelerationStructuresPropertiesKHR = vkCmdWriteAccelerationStructuresPropertiesNV;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV(
-        vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
       vkCmdWriteBufferMarkerAMD =
         PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) );
-      vkCmdWriteTimestamp  = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) );
-      vkEndCommandBuffer   = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) );
-      vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-      vkAcquireFullScreenExclusiveModeEXT =
-        PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-      vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) );
-      vkAcquireNextImageKHR  = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) );
-      vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL(
-        vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) );
-      vkAcquireProfilingLockKHR =
-        PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) );
-      vkAllocateCommandBuffers =
-        PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) );
-      vkAllocateDescriptorSets =
-        PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) );
-      vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) );
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-      vkBindAccelerationStructureMemoryKHR = PFN_vkBindAccelerationStructureMemoryKHR(
-        vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryKHR" ) );
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkBindAccelerationStructureMemoryNV =
-        PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) );
-      vkBindBufferMemory     = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) );
-      vkBindBufferMemory2    = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) );
-      vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) );
-      vkBindImageMemory      = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) );
-      vkBindImageMemory2     = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) );
-      vkBindImageMemory2KHR  = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) );
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-      vkBuildAccelerationStructureKHR =
-        PFN_vkBuildAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructureKHR" ) );
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) );
       vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkCopyAccelerationStructureKHR =
@@ -107219,10 +107339,12 @@ namespace VULKAN_HPP_NAMESPACE
       vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) );
       vkCreateDescriptorSetLayout =
         PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) );
-      vkCreateDescriptorUpdateTemplate =
-        PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) );
       vkCreateDescriptorUpdateTemplateKHR =
         PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) );
+      vkCreateDescriptorUpdateTemplate =
+        PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) );
+      if ( !vkCreateDescriptorUpdateTemplate )
+        vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR;
       vkCreateEvent       = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) );
       vkCreateFence       = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) );
       vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) );
@@ -107244,13 +107366,17 @@ namespace VULKAN_HPP_NAMESPACE
       vkCreateRayTracingPipelinesNV =
         PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) );
       vkCreateRenderPass     = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) );
-      vkCreateRenderPass2    = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) );
       vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) );
-      vkCreateSampler        = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) );
-      vkCreateSamplerYcbcrConversion =
-        PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) );
+      vkCreateRenderPass2    = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) );
+      if ( !vkCreateRenderPass2 )
+        vkCreateRenderPass2 = vkCreateRenderPass2KHR;
+      vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) );
       vkCreateSamplerYcbcrConversionKHR =
         PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) );
+      vkCreateSamplerYcbcrConversion =
+        PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) );
+      if ( !vkCreateSamplerYcbcrConversion )
+        vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR;
       vkCreateSemaphore    = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) );
       vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) );
       vkCreateSharedSwapchainsKHR =
@@ -107266,12 +107392,14 @@ namespace VULKAN_HPP_NAMESPACE
       vkDeferredOperationJoinKHR =
         PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      vkDestroyAccelerationStructureNV =
+        PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkDestroyAccelerationStructureKHR =
         PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) );
+      if ( !vkDestroyAccelerationStructureKHR )
+        vkDestroyAccelerationStructureKHR = vkDestroyAccelerationStructureNV;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkDestroyAccelerationStructureNV =
-        PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) );
       vkDestroyBuffer      = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) );
       vkDestroyBufferView  = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) );
       vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) );
@@ -107282,10 +107410,12 @@ namespace VULKAN_HPP_NAMESPACE
       vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) );
       vkDestroyDescriptorSetLayout =
         PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) );
-      vkDestroyDescriptorUpdateTemplate =
-        PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) );
       vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR(
         vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) );
+      vkDestroyDescriptorUpdateTemplate =
+        PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) );
+      if ( !vkDestroyDescriptorUpdateTemplate )
+        vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR;
       vkDestroyDevice      = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) );
       vkDestroyEvent       = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) );
       vkDestroyFence       = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) );
@@ -107302,10 +107432,12 @@ namespace VULKAN_HPP_NAMESPACE
       vkDestroyQueryPool  = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) );
       vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) );
       vkDestroySampler    = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) );
-      vkDestroySamplerYcbcrConversion =
-        PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) );
       vkDestroySamplerYcbcrConversionKHR =
         PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) );
+      vkDestroySamplerYcbcrConversion =
+        PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) );
+      if ( !vkDestroySamplerYcbcrConversion )
+        vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR;
       vkDestroySemaphore    = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) );
       vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) );
       vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) );
@@ -107314,6 +107446,7 @@ namespace VULKAN_HPP_NAMESPACE
       vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) );
       vkDisplayPowerControlEXT =
         PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) );
+      vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) );
       vkFlushMappedMemoryRanges =
         PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) );
       vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) );
@@ -107335,22 +107468,30 @@ namespace VULKAN_HPP_NAMESPACE
       vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID(
         vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-      vkGetBufferDeviceAddress =
-        PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) );
       vkGetBufferDeviceAddressEXT =
         PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) );
       vkGetBufferDeviceAddressKHR =
         PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) );
+      vkGetBufferDeviceAddress =
+        PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) );
+      if ( !vkGetBufferDeviceAddress )
+        vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
+      if ( !vkGetBufferDeviceAddress )
+        vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT;
       vkGetBufferMemoryRequirements =
         PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) );
-      vkGetBufferMemoryRequirements2 =
-        PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) );
       vkGetBufferMemoryRequirements2KHR =
         PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) );
-      vkGetBufferOpaqueCaptureAddress =
-        PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) );
+      vkGetBufferMemoryRequirements2 =
+        PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) );
+      if ( !vkGetBufferMemoryRequirements2 )
+        vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR;
       vkGetBufferOpaqueCaptureAddressKHR =
         PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) );
+      vkGetBufferOpaqueCaptureAddress =
+        PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) );
+      if ( !vkGetBufferOpaqueCaptureAddress )
+        vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR;
       vkGetCalibratedTimestampsEXT =
         PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
@@ -107361,18 +107502,22 @@ namespace VULKAN_HPP_NAMESPACE
       vkGetDeferredOperationResultKHR =
         PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkGetDescriptorSetLayoutSupport =
-        PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) );
       vkGetDescriptorSetLayoutSupportKHR =
         PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) );
+      vkGetDescriptorSetLayoutSupport =
+        PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) );
+      if ( !vkGetDescriptorSetLayoutSupport )
+        vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkGetDeviceAccelerationStructureCompatibilityKHR = PFN_vkGetDeviceAccelerationStructureCompatibilityKHR(
         vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkGetDeviceGroupPeerMemoryFeatures =
-        PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) );
       vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR(
         vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
+      vkGetDeviceGroupPeerMemoryFeatures =
+        PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) );
+      if ( !vkGetDeviceGroupPeerMemoryFeatures )
+        vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR;
       vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR(
         vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
 #ifdef VK_USE_PLATFORM_WIN32_KHR
@@ -107383,10 +107528,12 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
       vkGetDeviceMemoryCommitment =
         PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) );
-      vkGetDeviceMemoryOpaqueCaptureAddress = PFN_vkGetDeviceMemoryOpaqueCaptureAddress(
-        vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
       vkGetDeviceMemoryOpaqueCaptureAddressKHR = PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR(
         vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) );
+      vkGetDeviceMemoryOpaqueCaptureAddress = PFN_vkGetDeviceMemoryOpaqueCaptureAddress(
+        vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
+      if ( !vkGetDeviceMemoryOpaqueCaptureAddress )
+        vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR;
       vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) );
       vkGetDeviceQueue    = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) );
       vkGetDeviceQueue2   = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) );
@@ -107403,16 +107550,20 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
       vkGetImageMemoryRequirements =
         PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) );
-      vkGetImageMemoryRequirements2 =
-        PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) );
       vkGetImageMemoryRequirements2KHR =
         PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) );
+      vkGetImageMemoryRequirements2 =
+        PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) );
+      if ( !vkGetImageMemoryRequirements2 )
+        vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR;
       vkGetImageSparseMemoryRequirements =
         PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) );
-      vkGetImageSparseMemoryRequirements2 =
-        PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) );
       vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR(
         vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) );
+      vkGetImageSparseMemoryRequirements2 =
+        PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) );
+      if ( !vkGetImageSparseMemoryRequirements2 )
+        vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR;
       vkGetImageSubresourceLayout =
         PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) );
       vkGetImageViewAddressNVX =
@@ -107452,24 +107603,30 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) );
       vkGetPrivateDataEXT   = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) );
       vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) );
+      vkGetQueueCheckpointDataNV =
+        PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
         vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      vkGetRayTracingShaderGroupHandlesNV =
+        PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkGetRayTracingShaderGroupHandlesKHR = PFN_vkGetRayTracingShaderGroupHandlesKHR(
         vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) );
+      if ( !vkGetRayTracingShaderGroupHandlesKHR )
+        vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkGetRayTracingShaderGroupHandlesNV =
-        PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) );
       vkGetRefreshCycleDurationGOOGLE =
         PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) );
       vkGetRenderAreaGranularity =
         PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) );
-      vkGetSemaphoreCounterValue =
-        PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) );
       vkGetSemaphoreCounterValueKHR =
         PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) );
+      vkGetSemaphoreCounterValue =
+        PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) );
+      if ( !vkGetSemaphoreCounterValue )
+        vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR;
       vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) );
 #ifdef VK_USE_PLATFORM_WIN32_KHR
       vkGetSemaphoreWin32HandleKHR =
@@ -107500,53 +107657,6 @@ namespace VULKAN_HPP_NAMESPACE
       vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) );
       vkMergeValidationCachesEXT =
         PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) );
-      vkRegisterDeviceEventEXT =
-        PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) );
-      vkRegisterDisplayEventEXT =
-        PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-      vkReleaseFullScreenExclusiveModeEXT =
-        PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-      vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL(
-        vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) );
-      vkReleaseProfilingLockKHR =
-        PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) );
-      vkResetCommandPool    = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) );
-      vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) );
-      vkResetEvent          = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) );
-      vkResetFences         = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) );
-      vkResetQueryPool      = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) );
-      vkResetQueryPoolEXT   = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) );
-      vkSetDebugUtilsObjectNameEXT =
-        PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) );
-      vkSetDebugUtilsObjectTagEXT =
-        PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) );
-      vkSetEvent           = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) );
-      vkSetHdrMetadataEXT  = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) );
-      vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) );
-      vkSetPrivateDataEXT  = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) );
-      vkSignalSemaphore    = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) );
-      vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) );
-      vkTrimCommandPool    = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) );
-      vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) );
-      vkUninitializePerformanceApiINTEL =
-        PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) );
-      vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) );
-      vkUpdateDescriptorSetWithTemplate =
-        PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) );
-      vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR(
-        vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) );
-      vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) );
-      vkWaitForFences        = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) );
-      vkWaitSemaphores       = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) );
-      vkWaitSemaphoresKHR    = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) );
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-      vkWriteAccelerationStructuresPropertiesKHR = PFN_vkWriteAccelerationStructuresPropertiesKHR(
-        vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) );
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      vkGetQueueCheckpointDataNV =
-        PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) );
       vkQueueBeginDebugUtilsLabelEXT =
         PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) );
       vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) );
@@ -107559,6 +107669,62 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) );
       vkQueueSubmit   = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) );
       vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) );
+      vkRegisterDeviceEventEXT =
+        PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) );
+      vkRegisterDisplayEventEXT =
+        PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+      vkReleaseFullScreenExclusiveModeEXT =
+        PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+      vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL(
+        vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) );
+      vkReleaseProfilingLockKHR =
+        PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) );
+      vkResetCommandBuffer  = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) );
+      vkResetCommandPool    = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) );
+      vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) );
+      vkResetEvent          = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) );
+      vkResetFences         = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) );
+      vkResetQueryPoolEXT   = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) );
+      vkResetQueryPool      = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) );
+      if ( !vkResetQueryPool )
+        vkResetQueryPool = vkResetQueryPoolEXT;
+      vkSetDebugUtilsObjectNameEXT =
+        PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) );
+      vkSetDebugUtilsObjectTagEXT =
+        PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) );
+      vkSetEvent           = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) );
+      vkSetHdrMetadataEXT  = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) );
+      vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) );
+      vkSetPrivateDataEXT  = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) );
+      vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) );
+      vkSignalSemaphore    = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) );
+      if ( !vkSignalSemaphore )
+        vkSignalSemaphore = vkSignalSemaphoreKHR;
+      vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) );
+      vkTrimCommandPool    = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) );
+      if ( !vkTrimCommandPool )
+        vkTrimCommandPool = vkTrimCommandPoolKHR;
+      vkUninitializePerformanceApiINTEL =
+        PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) );
+      vkUnmapMemory                        = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) );
+      vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR(
+        vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) );
+      vkUpdateDescriptorSetWithTemplate =
+        PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) );
+      if ( !vkUpdateDescriptorSetWithTemplate )
+        vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR;
+      vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) );
+      vkWaitForFences        = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) );
+      vkWaitSemaphoresKHR    = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) );
+      vkWaitSemaphores       = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) );
+      if ( !vkWaitSemaphores )
+        vkWaitSemaphores = vkWaitSemaphoresKHR;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+      vkWriteAccelerationStructuresPropertiesKHR = PFN_vkWriteAccelerationStructuresPropertiesKHR(
+        vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) );
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
     }
   };